{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2e4cf5b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets,transforms\n",
    "import time\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5db1da9a",
   "metadata": {},
   "source": [
    "# GoogLeNet的PyTorch复现（猫狗大战）"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c38c1ee",
   "metadata": {},
   "source": [
    "## 1. 数据集制作"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f75f426b",
   "metadata": {},
   "source": [
    "在论文中作者使用的是ILSVRC 2012比赛数据集，该数据集非常大（有138G），下载、训练都很消耗时间，我们在复现的时候就不用这个数据集了。由于MNIST、CIFAR10、CIFAR100这些数据集图片尺寸都较小，不符合GoogLeNet网络输入尺寸227x227的要求，因此我们改用kaggle比赛经典的“猫狗大战”数据集了。\n",
    "\n",
    "该数据集包含的训练集总共25000张图片，猫狗各12500张，带标签；测试集总共12500张，不带标签。我们仅使用带标签的25000张图片，分别拿出2500张猫和狗的图片作为模型的验证集。我们按照以下目录层级结构，将数据集图片放好。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10a8d093",
   "metadata": {},
   "source": [
    "![](./images/path.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a62f2c02",
   "metadata": {},
   "source": [
    "为了方便大家训练，我们将该数据集放在百度云盘，下载链接： 链接：https://pan.baidu.com/s/1UEOzxWWMLCUoLTxdWUkB4A 提取码：cdue"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "723e6b08",
   "metadata": {},
   "source": [
    "### 1.1 制作图片数据的索引"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8663e72d",
   "metadata": {},
   "source": [
    "准备好数据集之后，我们需要用PyTorch来读取并制作可以用来训练和测试的数据集。对于训练集和测试集，首先要分别制作对应的图片数据索引，即train.txt和test.txt两个文件，每个txt中包含每个图片的目录和对应类别class（cat对应的label=0，dog对应的label=1）。示意图如下："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd5ba8c0",
   "metadata": {},
   "source": [
    "![](./images/index.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c52a6d05",
   "metadata": {},
   "source": [
    "制作图片数据索引train.txt和test.txt两个文件的python脚本程序如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ebbb8523",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "train_txt_path = os.path.join(\"data\", \"catVSdog\", \"train.txt\")\n",
    "train_dir = os.path.join(\"data\", \"catVSdog\", \"train_data\")\n",
    "valid_txt_path = os.path.join(\"data\", \"catVSdog\", \"test.txt\")\n",
    "valid_dir = os.path.join(\"data\", \"catVSdog\", \"test_data\")\n",
    "\n",
    "def gen_txt(txt_path, img_dir):\n",
    "    f = open(txt_path, 'w')\n",
    "    \n",
    "    for root, s_dirs, _ in os.walk(img_dir, topdown=True):  # 获取 train文件下各文件夹名称\n",
    "        for sub_dir in s_dirs:\n",
    "            i_dir = os.path.join(root, sub_dir)             # 获取各类的文件夹 绝对路径\n",
    "            img_list = os.listdir(i_dir)                    # 获取类别文件夹下所有png图片的路径\n",
    "            for i in range(len(img_list)):\n",
    "                if not img_list[i].endswith('jpg'):         # 若不是png文件，跳过\n",
    "                    continue\n",
    "                #label = (img_list[i].split('.')[0] == 'cat')? 0 : 1 \n",
    "                label = img_list[i].split('.')[0]\n",
    "                # 将字符类别转为整型类型表示\n",
    "                if label == 'cat':\n",
    "                    label = '0'\n",
    "                else:\n",
    "                    label = '1'\n",
    "                img_path = os.path.join(i_dir, img_list[i])\n",
    "                line = img_path + ' ' + label + '\\n'\n",
    "                f.write(line)\n",
    "    f.close()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    gen_txt(train_txt_path, train_dir)\n",
    "    gen_txt(valid_txt_path, valid_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edb2f375",
   "metadata": {},
   "source": [
    "运行脚本之后就在./data/catVSdog/目录下生成train.txt和test.txt两个索引文件。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3085c6a",
   "metadata": {},
   "source": [
    "### 1.2 构建Dataset子类"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09829c0d",
   "metadata": {},
   "source": [
    "PyTorch 加载自己的数据集，需要写一个继承自torch.utils.data中Dataset类，并修改其中的__init__方法、__getitem__方法、__len__方法。默认加载的都是图片，__init__的目的是得到一个包含数据和标签的list，每个元素能找到图片位置和其对应标签。然后用__getitem__方法得到每个元素的图像像素矩阵和标签，返回img和label。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d4f87901",
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "from torch.utils.data import Dataset\n",
    "\n",
    "class MyDataset(Dataset):\n",
    "    def __init__(self, txt_path, transform = None, target_transform = None):\n",
    "        fh = open(txt_path, 'r')\n",
    "        imgs = []\n",
    "        for line in fh:\n",
    "            line = line.rstrip()\n",
    "            words = line.split()\n",
    "            imgs.append((words[0], int(words[1]))) # 类别转为整型int\n",
    "            self.imgs = imgs \n",
    "            self.transform = transform\n",
    "            self.target_transform = target_transform\n",
    "    def __getitem__(self, index):\n",
    "        fn, label = self.imgs[index]\n",
    "        img = Image.open(fn).convert('RGB') \n",
    "        #img = Image.open(fn)\n",
    "        if self.transform is not None:\n",
    "            img = self.transform(img) \n",
    "        return img, label\n",
    "    def __len__(self):\n",
    "        return len(self.imgs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a9eb946",
   "metadata": {},
   "source": [
    "getitem是核心函数。self.imgs是一个list，self.imgs[index]是一个str，包含图片路径，图片标签，这些信息是从上面生成的txt文件中读取；利用Image.open对图片进行读取，注意这里的img是单通道还是三通道的；self.transform(img)对图片进行处理，这个transform里边可以实现减均值、除标准差、随机裁剪、旋转、翻转、放射变换等操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edc0a3a0",
   "metadata": {},
   "source": [
    "### 1.3 加载数据集和数据预处理"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ade4de2",
   "metadata": {},
   "source": [
    "当Mydataset构建好，剩下的操作就交给DataLoder来加载数据集。在DataLoder中，会触发Mydataset中的getiterm函数读取一张图片的数据和标签，并拼接成一个batch返回，作为模型真正的输入。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "72d3ef1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "pipline_train = transforms.Compose([\n",
    "    #transforms.RandomResizedCrop(224),\n",
    "    transforms.RandomHorizontalFlip(),  #随机旋转图片\n",
    "    #将图片尺寸resize到224x224\n",
    "    transforms.Resize((224,224)),\n",
    "    #将图片转化为Tensor格式\n",
    "    transforms.ToTensor(),\n",
    "    #正则化(当模型出现过拟合的情况时，用来降低模型的复杂度)\n",
    "    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
    "    #transforms.Normalize(mean = [0.485, 0.456, 0.406],std = [0.229, 0.224, 0.225])\n",
    "])\n",
    "pipline_test = transforms.Compose([\n",
    "    #将图片尺寸resize到224x224\n",
    "    transforms.Resize((224,224)),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
    "    #transforms.Normalize(mean = [0.485, 0.456, 0.406],std = [0.229, 0.224, 0.225])\n",
    "])\n",
    "train_data = MyDataset('./data/catVSdog/train.txt', transform=pipline_train)\n",
    "test_data = MyDataset('./data/catVSdog/test.txt', transform=pipline_test)\n",
    "\n",
    "#train_data 和test_data包含多有的训练与测试数据，调用DataLoader批量加载\n",
    "trainloader = torch.utils.data.DataLoader(dataset=train_data, batch_size=64, shuffle=True)\n",
    "testloader = torch.utils.data.DataLoader(dataset=test_data, batch_size=32, shuffle=False)\n",
    "# 类别信息也是需要我们给定的\n",
    "classes = ('cat', 'dog') # 对应label=0，label=1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2767ed4",
   "metadata": {},
   "source": [
    "在数据预处理中，我们将图片尺寸调整到224x224，符合VGGNet网络的输入要求。均值mean = [0.5, 0.5, 0.5]，方差std = [0.5, 0.5, 0.5]，然后使用transforms.Normalize进行归一化操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a485d8c",
   "metadata": {},
   "source": [
    "我们来看一下最终制作的数据集图片和它们对应的标签："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c32e657d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaQAAABpCAYAAAB1TVfrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsvWmsLOl53/d7t1p7Pdvdt5m5sw+34QzFoSiZMQVLdixTAiwIEewYCmAhAhIncRQg+RgEWRxYiZJIloRAi5XEUoxEciKRWkhRJKUZUUORnOEsHHK2u597tj6nt+qqepd8qD49dyjSmsvYc8+Y/cdpoLq661T1+7z1Ptv/eUqEEFhiiSWWWGKJOw15py9giSWWWGKJJWCpkJZYYoklljgiWCqkJZZYYokljgSWCmmJJZZYYokjgaVCWmKJJZZY4khgqZCWWGKJJZY4EnhbFZIQ4nUhxEffwveCEOKeb/Mc3/axS/xFLGX2zsNSZu88LGXW4DvKQxIN/jshxO789Y+EEOJOX9cS3xpLmb3zIIT4iBDi00KIAyHE63f6epb4y3FUZPYdpZCAvw98DHg38C7g3wZ+4o5e0RJ/GZYye+dhAvwS8FN3+kKWeMs4EjK7IwpJCPG4EOIpIcS+EOKGEOJ/EUJE3/C1vy6EeFUIsSOE+O+FEPKW439cCPGiEGIghPg9IcS5t3jqfxf4xyGEqyGEa8A/Bv7ev5pf9W82ljJ75+FOySyE8GchhF8DXv1X+Xu+E/CdLrM75SE54D8G1oAPAn8V+Mlv+M4PAe8H3gf8LeDHAYQQHwP+C+CHgXXgc8A/+2YnEUL8O0KIZ2/Z9RDwzC3vn5nvW+Ivx1Jm7zzcKZkt8e3jO1tmIYS37QW8Dnz0m+z/j4DfvOV9AL7/lvc/CXxqvv0J4N+75TMJTIFztxx7z7c4vwPuv+X9xfn3xds5Du+k11Jm77zXnZbZLcd8FHj9To/HO+G1lFnzulMhu3uFEL8thNgUQgyB/5rGIrgVV27ZvgScnG+fA35m7tLuA3uAAE69hVOPgc4t7zvAOMwlscS3xlJm7zzcQZkt8W3iO11mdypk90+ArwIXQwgdGjfzG5lTZ27ZPgtcn29fAX4ihNC75ZWGEJ58C+d9niY5foh3z/ct8ZdjKbN3Hu6UzJb49vEdLbM7pZDawBAYCyHuB/79b/KdnxJC9IUQZ4B/APzGfP/PA/+5EOIhACFEVwjxt9/ief8p8J8IIU4JIU4C/xD4lf8fv+M7CUuZvfNwR2QmhJBCiAQwzVuRfJPE/BLfHN/ZMrsTcVLge2isgDFN4u2/BP74G+Kk/yEN42OXhlmlbvn87wBfoRHcFeCXvuHYe+bbPwY8f8tnAvhHNK7s3nx7mYtYyuzfqNcRkNlfmX9+6+uP7vS4HOXXUmbNS8wvZoklllhiiSXuKL7TCmOXWGKJJZY4olgqpCWWWGKJJY4ElgppiSWWWGKJI4GlQlpiiSWWWOJIQN/Ol6MoCmmaIqUkeE9oCubf+GdKIZXE+0OixOHntxInxJv2F8Ws2SvAOYcxBiEEZVmhtUYIQQieEAJSNvpTa4OUAuc81trme/P/LaRovisECIH3fnHcIaSU8//bkEkOj/3Gq4SG+eFDwHsHIbxpvxSiGYPmj4PRdCeEsH47Y/qvG0KIb4u1Iubj12yDQCxELYRsNoVACImUYv75m8sl0iSZ7xKU1iFCM2MQopF+YCGH5nTzbSAQFp9755BSELxv3t8yv6RQdLotvPMwl7NAQPBMJiWVnUCQzYwTi8MWM7Aojp7MtNYhN5JEN2NYVjWFdRgkWgmCCMj5XG/GQCCFQBAQCIQQSBFAgAgBoSTBB5wPeATOe3wA7+ezXzTvhVSIIIhFTb5yDDfZp/KBwcQR4QAwUUQpVHOhQhwKESEkzjmUkoTQzAdXDom0wQaBMAnN2earhhCIIOZyCAtalxACEG/MqeZEb6rE2bx588jJTMrmPjNa46xDSol1jgAYJVFKLb5b2rqZg/NpLG6ZmHEUoYQkiGZkitmMOE6YzWYYY6jrGgCtFdY6ECCFZHV19ZAth61qnK1QshnT8aQgiiIirfHBo4XAEfAuoFVzb1hn0VJRO0/tmuuvrUVJhRTNmqm1JDERxaxkUpYoKRECfGjY2t4f3rtvGpfD+/Utyey2FFKapnzoQx/Ce4+ar/Fra2torZFSMpvNGmUVwi0LjVgMpPd+MWgIgbWWL37xi5w9exZjDC+99BIrKyukacqrr77KyZMn2d7eJoRAr9dDKcWJEyfodruEELh8+TL9bp+NjWNYa5nNZotzhPmNeKiMvPcopfDeL7allHgZ6HfaBFtjqylFMW2E7wRSBpyvwFd4a0kiyXRWIlXUKD5bN4uBUnjn+L/+8JlLtzOebxfENygKsVA04pt+RwhBnMR0ez1GoxHGmGbsaG6sOE4AgVaGNM1Jkhh0RBRHSKkIwSOl4uL5cyjtqaoCaVY52NvFa8msrEjiFGgmelVVJLGey8rhvSMEKEtLHMeM93bQWlNVzfyalSUhBCJjeOLx78K6KSv943gVIbWmnFqEH/HSV2/y4tc+hw+mkbk+LHMA75pzf/HpJ4+czOI44rvP9bi4qrjv7jN89fo+n/jqlNNdz5lWxhd2hvjC0lUOFaeodk4mNUJEJLGllQh6UmPCgCzNWWkJUi1IjSE3gkhAnmd4D0mi6PV6ZGlGFEfcHCu+8tlPceEjP4y8/ix7VvNrn7vBhY6lcjXtLGV77T50HCHd3GBDYq2lLEu63TbeS5SNKC59kraWFMffhcxWMMEjZCNbpRQuNDKXdY0nMJpN6fVW54t3QMlocT8rrZFC4Jzjv/3pnz5yMjNKkWaKTBqmRUWn08ET2DnYpx3FrK+toSRU1nJldxtXN2uSc540jQkh4JzjrrOnyZREpjE2wDPPvcB9997Ds88+R/AOpRqFLYRojP8QQAR+4Af+Bp1Oh4PBLuPdPerxDhEVTmo+++fPcuHsSc6urlHYgshafBIzGc7oZwlewN7wgH7eYnNYcH1vn06nxes3btLPOySxohUn3H/faVrK8MyLL/O1qzeJ44hAzXBS0mq1KIqaKDJMpwVubkSurKwQxzFXrl5/SzK7LYUEEEWaNE1J05TgPdoYqrIABEoaEIFDo/zQE6nrulEQc8/q8LO6rplMJuCh0+01VrSQDEdD4qRRYs45/PyYXq9LmqZ4C+PxhLWVDbI8oapLoiTmRO8YK92Mq9e32Z/OwFukbCy3RoN7pABtFD4IpvvbhNkIM+ngfY00GukDLTwu8qgAyjukjCB1uABGxwgRSFNNOdUoYxtLR+W3O5RvO25VOoeyufWzQ4UtpSROEpIkoaqquRKKsTJCKYVWBikVsYloZe1GkcQxSRTPLSmNkoJ2u41zDuHhxPGcTSUpg6MoK4IL5HlOCIHZbEYSa4wxeF8tZK61QwhBr9ebX1ezkGmtqeua9fV18pamrjO80iStNp7GKpuOCtZWV1EyQUmF9w6pwsLTrqu/6DkfFUjZLDZJGiMlWJWwanZ4fOM4Xz2oSFqnaYVN7jre4ebBjPjsg7STjFldofA4Z7kuIoavvYSqRkzrAlfBmVxSVSNWj/XRvqaT5UyjDkkyo5VojPSMS8FJKxlvX6eHJ5ECOx1TxBHjMrC+2iIRCi01QTYKHqmIokZ5mMgQvEIj8Fpg05NkK+dIREltPdo08yyEgApxIxeTEIQgaXcIIaC1RmuFd4Kgm3lalRXMjcmjCuc9URpT20BVVZg4Io0jxkVJP4CZ3xtSCLwArTUh1Iv78HCN8oCtKirrEAjKskRKOHv2DK++dgkpA8ePn+TG5maznoqAtZbpdIpSGqUUOwcHrPey5j5v/vk8+iCIo4gZgmJW0M+ShfMg5WEkYR5pEIIw93q89xgTIbTk2mCPAFRVDcLS7WZIpZhOC5RK6PW61HXNcDgCoKqqtzyGt6WQjNGLRaQsy0bZWIsUHik1kYkIwSGkeLMSkLIZ6LnHpHWz+Dz55JNMp1MiE1FVNVIphsMRQgTW19eoq2byHYbljh8/0YQFJEwmB2R5jjYtjDGkxnD+9Gm6ecKN69t0Wx20aSyJ8XhMWZbND1aKEBzVZERbW0I7JviSfq9P7SuCDRgEhZ2SRgnT4Yg8jZjVHoJHJwpCwPu6CZ3Ippi5tvXtDOXbim/lEd0aBhVKIrUC34xZmnfIWj1mlUcKhTYROtbzxSKh1eribI0wijzPiEwbpRRZ3lh7URRh6xKRtsmNYjyccPH8KV7b3qLTX6MYT+j2UpxtvFgTScpyDKEFAeq6pixLyrLEGEVZlkRRhBCCWTUj9ob3vudBymJG1umTxt1G8UQRk3qMUhlRNEbHOdDMIzePEwohiPBIdTQVUnOZnkhI3HSGto7jCvbqGaMq4ty581TXB4TpiFRpsjwlyzM6pERRhFQSrQLR+WO88OSn6VQOK1Me7nm8TpgQ01GOLNXIE/fy7PUxB6KDLIdUteOUuISpS5SRCKGJqxFje4yWLLFFwKx18bLA2RrvJCFUCAFaeux0iooyisHrSNVFn7qbXqaRqlE61lqUmhtEdUCpBCsaDyiEwHhU0O30CUE03tPcg05VjAhNWP8oQgiB0YYsSylLC0BsDD7ERCbh2uYW950/TWVni/Cjc26enijRulmKkyQhUZJaQpAKRLPwCyHJsoy1tRUGgwHXrl1DzBV7CIFPfepT/OiP/ihlMSHkOXVdo42mDjTepVLzcC6LFIfWhrIsCarxcA8dh0CYOwO+iZbOnYc0SamqETWN0jJG0Wq3CDLgPDA/znvf/N/AwqB9q7gthdSEOhzGKEIQJFFMPSsRkSEEqOsSKRTBOpK80Zp1VTU/Jk4ZjoYURYExhsuXLzEaD1FK0On3+crzzwCOWTnBOUeaRQyHY6QSBDxBCW7ubM8n6JQkicliQ55l9Lp9elmLXq9NK4rx1nIwmxCCI8sy0jQhTdNmITKGWTGFekRfB5TOcT5QVzPyLCbogHeOdpahgyTqt7HW0Up6VLakqmps7fBBImVJMfMoHeGCvZ2hfFshhHiTRySEWCikw9ClUHJusTXWVqe/TrvfxwaJ95BlLaSWKK1QyjTeh1I454iimE67hzEGE0niOEYqRZgOiTtdeu2MwfYmo2Kb+y7chRMxPoC1jXzqup5P3BWcdURRxGAwwFrbLGCuZjQaLazjjuxw6uQGMsCxY8eQUUoaNyHdg/nNrdKUKklo5S1CKPHzG03Oc15H2dIWQhDJgAwW7IxQOU4eW+H1UhHW+vSPd5jquzl47QXIc1a7faLIYIxa5P6ETnDB8/BHP8bmS3/O4Po1inrK2vo6YW+Pwf6Ejc4q+9eeQ8vTnL/nbiQWTMT4S69Tz0oqPyOLoZtqSpWg7JCyGNFqtVBxgkRCMPjQKAkB1LMxmIRJfYa4e4q106fwXiKlIYhDS9tgrUVGEhAowkL5tNstyrKkna8s8smLf47AuaN7n0Eg+IAPNVEUkbdSJlsjXF1zfL3PYDxCKYEJCZaquQ/rimSlQzktkFoRoxqmWVC89NKLoCVbW9tobdjdHXB84wSjgzHW2UY5C5AIbt68wa/8yv/Kj/2dH+fiwxfwrqTY3cQoDUGihCQ2MaKWlNWMyMQoocjbGRaBriwmzXnpmZcRmWa1v4phF7RACMf+eEgs4XeffB5b12hq0B2KmUW4GusgeIHSmrIsSdKUqnKstjpMQ/mWR/C2FJJAkCQJzjXeTAgBJRXINzSgCgIXBOWsQseGophRVRU7013SNKWuLUUx49KlS0hhMElKt7eK1hGutpg4opyVSKFRSuJc45ntbe8Q64iVlRWwEWur66z2Vzh+4hSRiUhNhA+WooTxZMzmzjZZmiJEc3wIzSJs65pISZQ0SJ01CUetkUGgdRMO8t5TugrvPC4IvNA4axsFKQO2rqhrR1mDMJLppECo245+vi049EgPldLhvsPX4UJwqJAOF4B2t8dkOqPV6QOSNE3RSqGUahR8lhLHKXGUNJ5RlhHHMXHSeFFxHHPz0ogojonSFsdPnWV8sMtwsMk99z8EuoMUCVI1C9TO9h7Ol0gBxhigsa6qqiKeh4CVajwlow1pDNI1+9vtNlnSYW9vjxACaZbiRIUxhiRJQMxDS84vfrMjHNmQXWNtS2IlSIxES8uWjTioLac31vCTA9ZXz3D9la+iVUysNJEyIMBEBikECttY2UFy8pEPEkdfpr78LNpkrLYKhDCUJKx2FK9OHFmnhRQSKsFBZRgN9lk9kyFDQS+PKTdOkO0MyJOYrNMBXSKCQQSD0nJBOhmGmrjVpb+6ihEaqRxKxgip8XMykLMBo2OQjaVu5iSlJuwnydMmvGqMWeSca2spbb1I6h9FHBp9Yk6mEkKQZRmTyYSDgwM2jh3HugoBSBHwwVNqhZvOiLWksJ56TlKZekstmxDbtKg5tnGMm1s3yVotsk6b4fAAWTuUianrCghMpwWT8QFlr4+KVrjngYt87esvMCpm87xuEy5VKgKtSZMEqRpyiZQCKSQP3H8fN0d7OGupa4dzDjsLJO0uv/XJz5C0+5TFBBcC2hjq2YxYSVxtFxGXJEnmhhEEH/5ia9h/CW7PQ5rzJ7RWlKFhzERptHDJnHMkOmY8mTCZjAkTkHM3PY5jnHPkec5TTz0JeE6eOM9DD76PP//ClxnsjREYCIq7776P6XRKt9tlc3OzWSitR/lAojSr/eP0e6uoNKHd6ZLFMbjA+nqHP/3ck8zKGdPphMiYxSTR2sxjqIHgPa28Tz3ZRaQ1la2wHuI4x3vPcDhERjF1USGBKsBkMqYsa2a2ZuYguBSjJVpEqFaE1ke3d+ShFxTmE+NwTA73SymbUI+UECTeCdZa53CtAdoo0DFaB6QwJElKFMW08hZaQTtvE5kWcZbTSjUiTUnziCSJGe3eINUSKQPtbp8sitnbuUqxP+D+Ry8isjauKJvEbitlf7BPL01RUqICjKajhcvvpCQIS1omrPa6DPe3OHHiBMqkZPkKo8EWUmtE7dFKkrZidjchzRNUaPKRKmFx03xjDu0oQQqJ8AKjI5yEICOu725TmRVUcByMDnBUoAPSSIIJqFShlECgEUIhqIgAi0QEx+n7H2Z85cuIStO991GKl56lDJb7HniE117Zb8Ix1qF6EVHvOFlnH+3BipRkbYO4v8roukPYmtUsQauMWkmUpwkN1U0uRE5iOu02AoUKAqveMIqgmXu+rhEYbHAopUjSCCUjCAbmYfa9vT1avf4i3K9rSyb0kZUZgDZmwTA7VEqHEYcsa3Hjxg3anRxrLWlkmrRGVdH2jrbRbKvA1csvYyTc99BDjDsZs+GMIgmUxTYbK5qqPEBS0m3H3H/hPC+8fBlHwmS0j/eez/zRp/nAB74LrWOmouKuB+/D/tEnELwx37XR1P6wf9xcacyZci+//DLpaofCzdC6uU+2h0PSPKMTKeysRBiNLxXW1ozHY0KsSbM2k7JRtm5OGjtM2ajoX1PITgiBQEFQxHJuYQqBVhFFUbC7uztPwDVMO6kUURw1VmoQDIf7fOUrX8LZkk63S+VqRKwYTgeEMCONFSdPnabf7zMaRRTFhJMnTjdxSWvpr60ymkxo5x22trc4efYM+7u71GmTvCvsFBcbatE86EkKgdG6oQ0vLBeHBpyy7NqKThGYzYrGmknb2NpSVIFycoCtA3UdCCpCygyTdfHWocU8ca8UVVUtErpHEYcsR6XUQiHBG0rqkCSQxNk8P6TZ2tqms7JKkrcbZq8wSOWJo4QoikjijFarjTGa2ET0+6sk3TXyWJHHCZ1uRpJGXHvxJaJ2mzjuELym9lN6/TVubF3hQf8u7j55P6ODKba2WOfpZx2sr6mqmo0TJ8mmQ4IPHAwPWFlbY38wQ8sJW9dfJZKG0WjEvfefY1LWuCCZWUcc5wRbEnxBHGk6eYKzjjRNAbf4zVF0dA0IIQVKBLQQRDqwW1Y4lXD3xYsQHMfW1pFCsv6ejxC3FQGPKwt0EjVJcxoKN4ASDX1aAKQx25Ndvvb0FraUxPGMi6GimNYURYEwAmdL5Mo6N2djXrhUMSsdA72KFJKDNEermqyVN+Fd1RgO9TzHC5DPP1PSEEtNrd7cwPlQOWkVk0V6wcYSQpCmGVY0eZWVlZWFh3RoUCppFuc5anDeU5cVIzskBJjNZoxGQ7zzc8XkOXnyBEUxYW2lz+Bgl9WVFSb7+3zP/ReJlOXK9gEXVlYRvmazmvD+u8/RSVKmw106nTZSCIrakKQZWkkOUsH13V16qyd45otfBgKXL13m8uVLrKx3ec+7H2EyKnj8A49S7+8tmM1pEkFwaCWbuSYVCIUncObMGUa2oB3nbO3tMplMqYB7Tpzkgw9c5Nd/53chlggVcNbR6bRRoSEcaaUoihntThtrbUNGqStmt5Ffv23pHoY5JB7ZMA6bsEocc/bsWba3txeWgVRykRDbvHGVzc0b1LXn7JmLnDp/FyfOnOP5F7+6WAhXVlfY2NgAmuTeykpvwb+/99yFJjSUZgQbcMETtMQ7v8g3TOsJ3ns6nQ43bmwuLIJDheG9byyF0LD9Ot01JsM9RjOPEDDZ3MfamiRJKVwgy3NE5TFK47zDhoCOzZvyL0mSHFllBI284jhuFpB56OpW78iY5iZvt1ZotVoYI9nf36fdXeGeezeYTMdIk1DXU7KsgzGGPMtJkpRW3mG11yUIy9mzZ+lkMYmCNNVIBc9snKZKPGmcYSJDlRhm0wFdu8YXP/8U733oPlZPdue5yYAPq9S2wtbNAultRQiB/f19lFLUdc1rL3+Nq8MJrY0Ner0ek+mEstaYJEOg8FYjjQdfYKQnT2MCjZxCaDz1N4UVjiCklKSRJtICQcJOFYjaHXorK/hqRGrmbEYTE4LDVTO8ACU9Mogmgj4PgRl1yDLVlFIy2N7h9MZJJi1BNSp57otfJeizeO+pZjM+//SXuPTsi2BKrFpDiBrPDsJ/nUhINtopj7XzhhwiFZGQRM7hvMc5R7fbI8ta1LVHBYFXb5BpDr1SGQKCCC88URShtMDohOBZlJBEUcTe3h5ra2vN8QGE0Itw7lGDlpI87tBJFVsHY2Il6LVyRqMJWRSRaIVwNa045kRvjddkYDKrmYXAK1cuoQjcmBTs7w8QKlDUHuUdqdCMPOSxxkgQJiZq98hEjWmv0m5vsLOzw8bGBkVRMJs1lOu97SHPffE5YhfYLyvuufs0DklQGozA6xw7mfDkC69wsD/B2kCQjiRJWF3fYDydUDhHrlIyZ+kmAuELHJ5ekjCpKypX0U1azLwjNk0uMM9jQrBESYwPjjgxi8jaWxrH2xl0IUDIee2BUHAY9ggOHyyzsqK/0l3kInZ3dzkYjjg4GLC9uc10MubMmXPcfc8jnLrnQf7kyd/n6qUXUbVgtb/KiWOnmE4mpFlO3uqwP93lA/deJHjDvfc/gDGG3d1dRqOCPEnQWtFqZUzLgnFZEHYcw4Mha7015H2KwWiI1AoX/CJ8N5vNwGhEWdGJUoq4RRw0SkpCkERKEUlFJgTFtEA4j4gEWulFPNt7TxzHYOc5KR1jxdFMtgopiFsJSkmU0osaLGOiJomaJsRJzNraeXrdHt2kxWuXLrO+sc5jH3gf+4OayjWMmcgYojii285I4ohuK2N9tc9sNmOjn8yLHQ/PHPju730/X3j6BcbjMS7NSaIYX0dUNhBT8Is///P8xE/+BEIk2NCw6sbjMVVVsb+/z2Q8paoqhpNxc+22ZuvadaSAtXYLaTQCzUqnTRTFOGPYGQeYVXBgUMpz79kurXSDvNVCCkGSpiil6PW6rK9v8J/91D+8k+L5phBCUgVPrCXWVjgZsdpaoahKVrobiFAjdUAGiVTNAg/gCUzLMXFUo22MERIfDEpqSl0T6hRtamw1otNtsTmpiStF6+4LlK7mDz/zJFm+wsa970bYQO2mjPe3GU8scZQzHh1QlCVfff4ZHn3f43jpMUICTXmAEIJSK6QOJCZF+SZX0oTdAsyZc8I31G7m81FGZlEsHcUSW0sMik6WAM28dd5joujIekhN1XWYbwqkVGijF+8PCQjehyZXrSBLYkbFAS40hbJaQpbGSOlxwtNNY1paICrNWreDlgEnAjprkyqP0AlXXnyO2jsIgul0CoDWsgmDJykXT53mj/7saYw2+NAY5cNRyTOXrnDlxhaOCkUgSwwVCeNyxuTqFWJt0EqBdWRSU9maia9ot9t4X+NdQGpJWc6ogWAkhMBKr8/+cNh4XfM1o7oNZuTtSTfcYuWoN6qGDyvoD+tYDimE12/cYPfmNfaHBaePn+cH/+aP8t7v/Si/9Ynf55N/8Jvs3ryKrQqOHT/L2bNniaKIuvBs9HIuX3qRD587iZ0Nue9dH6bV65HnOcePH0cqycHBAVprJqMhdV0w2N5iPJ4SxzFJMk+05xnee/I0W9BF4yRFKMVoXDEtJnTjNid6TWFtMRlj8UzrCh2aUFeWZUzrcuFlKaVYW1trFJt1ZGlKCLC9s3NbQ/l2QSnFWm+jmVxzGSkpyVst8rhFr7tCr9vl7vvu4a677mJ1zfLHn/5t1rM+3/3oAzhfM5spqqpsWHTGoBUoJZHzLhe9NH1TOLCBoNvrEKg4ce4kk9KinMdVkryVYscTVlZW+Z9+5ue5596znDp1FzdubLK7u4tzbs6qCyilCb6JRx871uVgb0AcRQQO85M1k8mU0aygmFm8C3QTy7QcA/Da1U1anS16ZY92q0U76hDrmFE9ZXj9xtssjbcGKSRKgkURCUjynN7aKnm7QxxFaGXwoUIHwyGXplnwxKJGK4iAn9aLjhoaxcqHPkz5uT+mrEZUw4pKtNhNusRK8Tu/83GGk4LuimR9dYPu2iraSLaudOnOZuRxxNXLrzKbjfmt3/w4n/70H/Bjf/fvc8/50xDeCKUZoxmNB7RaHZQLTSRFyqahA3KRw2vCcA2N38s32J/e23l3FE+apkzLKVHUaUpFIr2I0BxJ3EJmCLzRReaNEpiAoiF/GBGovaWtFPeeOk1sBC/e3OLc8RNEkeTmqGS91yFXgmw0ZG0lB2+p6py8v462BU4bhLMkSUQc5zgn3eZZAAAgAElEQVTnqKpysdZtbW3x2MOPoLUiigxaaUzkub53wOuXriCVomU0lQ+EKOPBux6hGyu+/PSTTOqKNMkxtaBwNYmJqCZTqqokywxCNEZFv9vl+u4OwQeCkKRRTKE0zCnmQsrDqou3hNtTSEI01opz8zYhiuA9UZTgfDMIe4MBOztbXL92jdlkyt/7ge9DZcd5/Af/NoWFT33q43zlS7/DbH9Inhp6x85w/vxFfFXx3kceZq3f4tjKMbrJx7g5PGAkp7SzHrlKOXnyJFEUcenqq3zq93+P2tbERtNqtzh5/BibYkC302EymZC02wwPDqjrmkhq4jxDCMFgb8DZY8d59PEnCN4ipJ3HsSUqJDzz4vOM93YQUuKsxTo7Z5al9HpNCPEwgSu0YFYVCATtztEsjI2jiHvvOUsUxeR5jLU1zntOnDhBHAm63TYC6K6UROk+6ARpJFU5JYQaQkmWt8iybMGWUUIAvkmIzhcYZ13DUOQNVo0Qnlk5IBoZEIYkSxntl0SRIciGMbe9vctwNOSFFy7hnGNrawuAPM9p5R2yzFBNx0ymU9b7OQZJ7eqGtdRrqObdTp9KQz7zzMZDkkhy4CWTScGrV7fIsz5xtI9UQ9J0gFaKJEnviDzeGpq+PjJKkcbikJgspp1mDVNKg1SSSMT4UM+LiDVuPvbGGNTcQjBGNwWMyuF8xInHPsQX/viTdFrH+PDH/hq//Iu/zOaf/R/UAVbWj3PXhQvs7uxRFhMOdmuSSLO+eoLNG5tcuOc+rt+4zN7mNqNhyT/91f+dj/3gX+Xxxz6MmRtscRwxGg8ahqv1RGpOsQ8QQmMQ2fl1xqqpWRNGL3IOCIlXCh0kUjlu7m3T7mQ4DypI4uioyq1ZoGvbUJxDgGlRIA/bLDU3Cx5QUqCUJNMGOzogkxLjG/r2rCgYj0v2C0ciJaOyYDS0nOodR4uAkqCsR9QOYQxaCWazkl5vlQ8+8UE++5nPNC18BFS148rVa9TWs7ezixtNmc5mvHDpGsZoTq1kfOT9H+RTX3wW3+rx2Hs+wLvuOcUTDz/Af/NLP0dZVXSSLoWrMUox2xvNjXKNB1zVsPsEEucsRklC8Bjd3N9N8yOJkm9dzdy2/1tbhxBgqxmj0Yid7W32BrsIERjs74KX5EmLey/cx1/7/h/iPU98L2UW+Cc/9/Nc/drL2OkePZ3ieoYnnniC0WhEHgnGV7e59CefZOfkCeSj38OkVRPFGjERnDzVxTmB9SWXLr3Oi3/+p5x68G7ydof9q5v0u02Lm16egqvp5imzsqDdUpw6dY6qLImihFa7jbr7DMFWzOqCNMlQaZs8ifHeU492+a7H3sul3/19MJI4Tun3+4v8xWw2exNdWggzn2uN5XMUEUJgOpvigqOsp4xGY5SS7O7toU2OUgYTGVrtLVZXt2h1UhyOnf0bPP/yJXaG++RpxvBgSG+uAJIkITIRtbWkaU6apthiAq5CpdG8MK5iMp5glEAJQTtPuLm7TV2V1NMxtXVM94dERhGpDKMNdVnTbXcpyxlnT5+lmNXERqATzdrqBqPBFlEiCJVAK4kvA7qtCcKjaVHWQ9qpY1ol6FiwtTVgd7RDWVVkWdYkhcsYQeM5HtVHU0qlENbivGY8K9C6w5mz50nmpAUhwHuHARA13ivKcoKdeyNSSkLtcM5SVTUheIqypmNypmnOQx/56xw/fYb/8Rd+kfFgSHAeoWKMirl+fZO7zp/jK88+y7kL5zm4ucX2tdfpnzjFzmCPWEj6a2sM9oYURc3/89t/gHMJf+XD30ukNF425Jc0zRe5V+c9Yb6QOSuaQlil5uyuQBCQZTHQeHpOepSQ1DZweu00ZbmPUBnVdISdTe6kaL4lfICK0PSRU5rgPLUXxFohtZkX00tkaEoOfGjYj1JHhChQOIdWGoRhWlvavR5RlLBfzghJRBUqlAqUXqGNJ3iNDQorAlIarly+zOuXLxHkoacZUEri4xghBXcdO46LY5778jN4HbDK8W99z+M8cd+7eeqVSwz2B3S6G1y9coXrVy81JRZ1hWspcBZfznh1b4yzNVVp8UjaWULwgSSKEaEmjkBqS/DgVQ1CEomEqXrra+NtKaTh8IBP/eHvMS2mKPQ8nBJotzt0e2ucPPEgj33wI/zwj/wtauGYFlP+wX/6H3B8JeZY1uHCasxNJ3j3o4/TbneIooh3vevdHFtd56VnvsB9d52l3+kRqYQBQz739BcpR4oXn3qK51/7Citra4ydY3a6xX2XPK+MFI9+6HvY27zB6TOnGU4GJGnC/v4+/V4XFTTTQUEUxfT7HfCglcYpTZJl5K0OOk6aRoh1xZ7dZ1xOuXnzMmurJ+h0ugva8a2Mn8OC0MMuFFI2lc5HEXVtuXL1xiKMOZvNFpRMHY3RJpozDAdsbd0kShKCc1y+9HVe+OpLXN3aJVa6KSqdJ5sPw6JaN+GjhtghMCIglWAynRK8Y1ZPiGWEMRnOQiuN8DNBHSyzWUntBd1uFykiZlXjOUEgTXtkeYZUFVXRxKOvXL5EHCt6eZt20qa72kdqyXQ8Jotz6mJIEoETOWFWoIabPPfiSxT2AFEp6rLGGIOcFEc77EPjYHakYe3C3Vx96Xn6vR79/gpSNT0Cm8VGoYRHa0XwCudbQFgUkx5W44vAfF+jhNM8Z1LW/A8/8z8zPhjjQkAEWO2vEpCE2YQXX3yFhx94kEvXL1GMRoxGI0pv6fWOkycnGde7XN+8hNBthFjnE7/7L1hfbXF8bYPjZy7Q6XTJs3zeCmoewpr3NyQYrHCLsFITzmJR/3dI867rmjTP8JVnf3OPXt/gSsvBwehOiuZfijRu2pgFHc1bnFXzup+m16W1FiUa09U7j45MU+BqHVJJnIdWntFpxwysIJJwYmONrcEBXkpsAIuntDWRaPLDBAjO8cTjj/PU009TO9v0twNs8HzhmS8D4NOUmzsDqpmFEGG84LN/8jIvfH2bKDUcXJ1wc+8Sv/Px3+VkJ2JDKLZNxP7BDlkeMa0cN7Z3CEFSVw6tImZFTSItQpk3muy6gE8MyltCUCBK2q3eWx7D2+v2HaecOvcIcdbChynt9hoXzt1La6VNFHl+8zd+i//7t3+df/5b/xvrq2tcOHOKh85sMBwOuXbzJufPn2fj1AlAcHCwj5Ixj73/Q/z2P/8NHn/3g5y7eJHNzU1eu/Yqe3t7dEzOWBZUScyP/ciP8v/+ySdZPfUezp2/i/LPPsPXBq+Qa8WxB+5lf3+HXjtHSY3uriGkZqW/RlmVeOtQAlQck7VyFAJpYnScgskJtaW0exBmfPapJ5mOCg70AGM0SRLNKcO8idQALOjt36yj+FFBCGHRS+rwZj8Mjxx2SwCoypIsyzBliXWOvcEWuzu77GzvE2u1CAsd3mBxnJBnOT6Epuedc/RaKcE3+R9rLcjAuo5RosbWlmBLhLOMh0N2trfprx9vGJpRxPr6OsPhEO89x44do5zNCDShQO8DURQzKQpi48iyHOcqZOSIVYqvakRdImJDOZji3ITdwYQbWzdJ84qpm84bWTa/ddFY94iyI4N3aKnZubbDsY3ztOucKIoWfeC0bjodJGmEd7JZ6EWOEc181EbPC38V0WELHgNRbEjSmF/92V9gsD9papZomgibyKCimMjO+Ojf/BGuvfIcx9bWeW13pzHErKccD2itJXzXo49x9eorICxJkjErSo5vnCaNYsqyZHV1dV5A7xY9K6u6oq5qpEwQkV90BYniCO/mtO5bWuHE8bzhaCa4q/UIN2+8Qre1RhwdzdC4FIIsSogzSy0UsQChFbWzLBqhzqdb0xAVmDeZ9cHjraeyDrzHSIsUiiiSCAVBeaz3SCRe0HhYCNxht28paac5OPcNhahvtAfbG425fP063gtqoTgbzfjpn/xhfupX/4DpeBNdeaSJuXDubv7Ge89z4+t9fu3zX0GGGhcEs6omTnJaWcpwOETrGHzA2kDLZJw5dpLXLl8lqZqefR2ZNj0vlSdv9d/yON6WQoqTjBO9iBdfeYVpWVBMn+crX/o8edZlZS1hpacgtBAu0G0nHOzepL/W48SJE82jGm5ZHMVcQVy/fp0HH7yI0Ql1rWjHHV4ZvIohpq73ybOEopzyhWde5mT/bjbaOSe8wd3/Prr3PsCV1y/RXe3ifcXa+mrTPDCOESZmZh3rvQ2UCxAHorSDUCmSkklRN00gbUFdVsyGe6yurHD50qV5591m9hyG6w77qDWtcqLFjbNoSHob/ZreToTgF96b1hHO2XmMWWCCQFi3+A3j8ZjMWqoqMJ4OuLk7wE5Kxm4CQhDpCCnNXCEVWNv0vppONTJAcbBP3oopigLrLHjHtprRSiFtZ+yPh+zsDTiYVgQZ4z0oHZNkCeNROX+sSLWojRqNZ+wOD4i1IghJv7uC845rW9ucP38GP5uQd3rsDwe0EoNwinq0Sa0FT3/pNawfMZ0KkqRaGBPOe7RU8E0el3FUEEURAyLG46tMbIJu3YOJ1NwrkkRKE2mNkIo8S6hrSxxnGNyCxGBVUxdya9cAaSIQEc8+8wJKJguygfOO4Wif9dRwbO0Yn/34v+Dedz1MfbDH+fP3UFUVW9cusdJpo7TkT5/6PGnSpa7GZFlGZAJ53kEBZVHSXV1taqKIQHoSmkU4NKmkxXxruhxJQrAIAc75pu6PxuirrcVPa7QyZGmXuB0R076TovmWCIDJU6rqAE1E0DFRPcCbGCUtVhhkXSMISBEIopnTIViCl/NmNwqExfmArRy19qSAoanjrLFYJzAhwvoZzfMlAlJZ0lRw/7138+zXv87hszy00gTrwUOtU6rCI5TEuAn9Tsa7Hz1H7xMbFMUAmcF47zr3XzjOr3/8z9jeewlX1QgryDb6bB4UtPKczb0BnX4XXVne9/AjnF49xmeefob7jp9gc2vIg/fcy/PXtrn/1HFePbgGasY9Z47z5Fscx9vr1OAqvFRcvPss03LWPFfFOWJtmM1mxCai025z+tTpNx0nhMB521gCweN9wEgzX9BqHnzgYW7euMb2eJcwczz2occZDnYZDAZMxgWj/QHpxjFqW3P1yiZXrtwg0RGdvMVBWfDyc1e5cOECk2ubtPKcJEnotVI2+mc42T3G1uYLECJWWx2k0njVI8umjEYHDMsJw71ttJD87K/+MgdFiRKaLO2QZ13SpI28pdp80bl8rmAPQyTBH82MRAhNc9oQAnXt3tQ+6FBRee8J8wLaqqrmymnIaDRmOpxRi6ZweMYMkBgTEcdNrqiqmhY9tmwW/ZOnNhiPx029SHC04pSyKlGlYm9vj9FoRKfTpdvtz2vPmkek7A/GmKjp6N5utxkMBuAtaWzI0myeqIfhcEiaZsymBaurK2gRiE2zWO/t7uGmA0JnhSruzeeX+gseolMKwtH0aAGKYoqWGXGaM54F+qdONOHGWzpqKNm0vHLOEcdRU+jry3mRI/MQWfMbD+domqYoaTh96gxXr94gTdOm2z6Coii4fu06fjTh8Se+j9euvUqSSrZv3KCuaoQW7O7tc6a3QiCwvrHGjatjoihiY61LHEUIHzBGEUfx4llJi5ZVPjQhqrl3fmsuNgS58I7StKmbOvSgwtwwXAlr1K4gid96+OdtRYB2ljPe9QQR6Ha7zHaa+kgZPDo22No2LZbCmx/P0zQcePP6obVe7HHWz7t2N5qm6ZfnF93PBU0Lt43VNXjp60Az/N45zp45y9VrV/G2Bhze1ljXYqdo8/1/97+iyPuMhwc88sj7uXljk167RVFMSHp9BlubxElM7Dx16YgSw/rqKjv7A4xr1vFZVWGiCKQga7eba5bN2nLfmdNsbW6R9d66EXFbCqmumyaXURTRb3WIkxhjImbljHa7qc71zhHHMZ1Oh/F4/EZ/J96w1Jvnm0SLm2T1+DE6WcpoNqbWMJlM6Ha78+e0tDl+7DRP/fnn8c5x+vh60/NpVrK3u0uSZ4QQePXVV3no/ouNdW4t7XYHq/YQURunBFp4nK9QpmnoSJA4F6jGB7TaLf7Zr/+f7OzsEgK0WzndbpdOp8lzCdm0/zhsDHnIMDwMRzTsouR2hvJtQyAsQlVy3oX90Ou7tTDUM6+on1NUy7Jkb28XV4B1k4bFJQRCaKQoKYxatEURQuBru6g9O6S5aiU4sbaBrWdsbt6gKAo6nQ79/gqTyZSVlRXyVoeiKBrlHglaeZfptHnfyWO8TUiyjOl0SjLvyJEnLYa7+whfYaKM4AQiialtjfMSbVKKomE7uXns/tbizOYxJPrIdo723pFHBhEiQqgpy+qNDgfRG626mHdVP7zHTJosvKFYvPGYh8M8p1IKow0/9MM/xM/97C8g5iFY6yqsbe7bg/GI2gh2t3d54KGLXHnlVQDe/b4PkKYtXnr+2eY5OMGzsrKC1pqPft/3obRGC4EwzaMjamtJ4oz/j7k3j7Fsu877fnvvM5871Vw9vJ7ePHN6JEVRT6KpgZQoS5EoAUGsCLYlGLJkOQ4cIHakQEkE+I8oDpIgjmVFdmQgDhJBDBQkUgZJlEhRnB/J9/j42G/o11NVd013PvM5e+ePfe6tapK2XgswVRtoNG7V7a665+yz11rf+tb3IfUS2gaxVMhYHMbYr2IMKCUwHCdNjuOgneM5pnw6t/N/p3SFfoArFbW2KjW0CIpCEMYxaV1jdL2c2bL96DYYY8/GZYCSAuUo6yqgbSIvTzBYpZAYKS0BprHzYCuDFc5ub7F7Zw+BYHtri8uXL3P79m2yZMZKr0M9LilNws40p9g8i5+nfP93fzcHk4T9wxE6T/ihD32A3/jtfwlKUFOyGrmUjsN0PGFle5OD+pDu6gAcieu7uFGAFwY2MClB3OkiXIUsas5vryHvY3bs/iA73+fSpcvtYSOXlodBOFhmyjgu09mMJE3Q2nD27FnKsqQqagStCKNh6eg6TxO8KMKTis34HNPZlCKd0+uEgLHCmVHA+fPr/OHH/5jxdMZjjz3DZDxGnReM52MqXbK/d0AYdzDGSp+Px2N8z+Hu3pu4nks/iJjNx+gEhtMxgWd183RT8Yd/+An2DvdBOThK0VtZZX19fQnT2UAqcR2FNgalFk60qn044e7e3fu5lN++ZcyJqm6Rmdl+SlXZ3b3E7psGLQVNU1HVOdPRhH63x3Sa2gfLdQCJkA5VpajLik63Q1mUNM3iIbPEhrLMCf0A33PJ5zOKssZ13WXi0jQNynHodDoMh0M2NtYpq5wgDJiMRwy6Eav9Dp6jCTs9rl9PqKqclZUeujHUWpPmJXkxR+IjtSaQit1Kci7sMRxeW8KqC5n/k0FJioXj8elbQRjRcx16nZhZM2Kw0ieOY3tQK9UaT4LDsfyTPbQbQKFUS2gQEsfBMilb8orrerz9bW/HdXy0qnFdj6IqcZTAcxR1Y9DC8ODDjyGlx7nzl7ize4eXXvw6Fy4+gOO6pHmG70p+/Md+nE9+6vNcPHe2lepykK5L3OkyOjrAce1esXvuuOcqhGXYyaWsEK1nlXX9PXZjbqWPpEAYw2BljWQ2+cu9Of+aJbBqDdKAHwT4vs9MNyCt/YPt+QWYtqe0gJDFIliL4+cQsUA1PCt4e2KZxvasTWs5K2j9swz4jsuVi5c4OjgiiiIee/RRRJuMoGsi38NzFaoyGFMzOdjlHY+9jQe2t3jhhf+X5z/4A9y5/RphoFjrrDBMDgiVIIw8GqnZ6J2nKjIuXbjA/sE+ZV0hPRc/8DFS0FsdoDyP3mrAeHQAnkPgOajsrUsH3TduEbWyMUJKu3nai9vtdvF9H200WZ6R5TlZnrGzu8P+wT5G2CwBqWiMtWA2xrC/v8/16zcotKGs7aY7c/4BkiQnKxqmSYqWVhT1/e9/P6tr6/w/v/f7TMcThqMReZFQFJllkdUNqmqIlEORprzxxjU+95nPMdzf5/beLg2GosgoxnsM927yxtWv88KLX+HqG68yTScgJJ1ejwuXLtk5nVZmxnW8VqnBKhP7XkCv28f1PCbTmR2K/ebJ0FOxFnj8wsrB/qnQ+niIbmGEaG0g7NfKKqPOS67dfJ28yKnqijzLaOqSssjJkoSqLMnTjDRJmM/nZFlOkuQ0jRWonU9m7O7sMEsThLLyUEEQkOU5URwvewn9fh+lJJ7rc3B4wGQ8JApckvmUIs9ZGXQZ9HqUVY5UoFzBxtkthBPw5pu3SIsJR/t77N64QQ2kSU7jVkv4cVHJLQa2m6ahqsv2AD99K0vnODgU0lAWFQ8/9ihhaL2OfM+3kkCes5R9WmoSKg/fC3EdH8fxcZ1WYki5SOHguQFNo+n1u/zYj/87eG6MlIY47limZFOjDVRFRlkV1kqgqtk+d4mf+ZmftdJfuuHC+YuIRnPh3HmefvRR0DW+b916gyCk0QYlJX7g4zgu1uZeLgkxVgbIwnULMz7aRGb5edrqzXUclLDJr+N4mFN6z4wQxL0epgloTMPkcJcCn1q71MbOC3lhjHBcGqFosNWq5zg02iCUiyNcjHSohcJU9nNqDC6Sea5IMkmtBdJoSq2o6hJjFK6jqE1FoAwbjuIDz38Hjz/9OKCZzMYoV5IkDXlVcnljhZ4fo4Eg9Dg3aDi/scYzzzyDFwfkpqIobvLRD/8gsdND9QYgPQ6OZhxMDql1iakr1nsdQhUgEayurlNKTdRfoXYEodvj8OgIPI30BdvbW2/5Ot5XhRQEAd1ul/F4vMS0F46fZVkuIbk4jpd9iwVEMp1O2bt7F9/323kWh7osSbOUL33pSwzPP8CjDz1M2IuIAo/B5jqeG5KmiZ0zcRy+8Gef5fz588ymOS+99BIPPPAAG9srKHUE1IzzydJCIohCTGbx86IomDQ5OIrb165zMBpiAofhtCZLJszyDBwruLmxsUkURa3B1LGc+uJAW0An+/v7iLbc7nQ6C/nK07eWfvfHzMBjqO5YkfiYdWZfN60DZZYmuB3bWxKeQ56nBJ5PWRTo1pG3KAqqqsZ4koyMTjdstdYckjQh6AVEUcTR0ZiVlXUODoZsXtxkOBxSVQ39fp8g8Dg6OsK0zex+v0+WzOh2uwghWVtbI+74HB0dIYSkNk2rIh9weHhIrHrLfVbpXbTRy0x0wfZaQHQnbexP4zJ1g3IlgecStSSSxbgBUqGx0LEpj+G4Rc9lUQkuoGXHdREcW4vYAGH4wR/6ANdu7PLFFz7DxvYWe7u3qPIURxpuX3+Tjc2zjEYjqkoTxz6f/exncV2PwaDHbD6jPxgw6EW8993P0mDwopCqMsSdzlJvbgFJnbRAsc+Qbn/X43x40Y+t23u0+LyLves69vN0Op2/lHvy5y2tDaPRCCkl8yzDi0Ncx2GcZCRJiXJW8N2Aiw9cYHjnRjvLp8gcHyPk8nMDyxELW8lDITQ3bt7Ad+Dy+QeWsPsiSVZKIISmrlPW1lc5TCsq4/Onn/wkXmip94eHh8Se4OLZy/RGc6oSzocuV85c4I3Xr/HpL72A/8o1TJMyUIYPPv8d9EOXrE7YOzxEKonrCNz2Z8ZxjOO4eJ7H9mYHp7jL5to6L37m/+M7vutHaJILvDl8Hd3YIuOtrvuqkHTTIDFsb2+ytbW1zDiLwv6R0kFoQZ7kSCNRQi2zIiEFQRTieC4HR4dcvfYGVVMTBiG6pXkeHR0xmUzI03TpGBoEPkopkrzgwYeu8JUXPs/aRkAUe2xs9ejGLvk8p6nBNA6OCHCkg+cqOnHI+UuXidY3cIzky1/5CrMyR3lWzqIXubz2xk36vXXObJznwvmHObN9Ac8Nlg+RHSzNcH2r/XY4POLg6BAj7Eao6waMQ5GfzjkkMMsDeEF9XvTDmqb+hsqpXr6vbhrSNKMsS/IiJ8tz8qKkMZDnqa2Y8gywU+FBYOe6+v0+rueSZRlFUXJ0eEhVlezs7LC+toXr+Gysb6CbhrNnz1oZlVbzy3Ecsizj8uXLxFFEt9tlc3MTpSRFnpMmKVmWEfj+8sBFFKRJhevZ4JfnGXmWEfrR8jA7+bkXLrR1Xd+XtfK3c9mqvICDO8R+iBsE1O3c26IqWgwox3GM3wrFep5nv98GBM/3Ua03leu6BGGIEBLXcxFS8x//g7/P93/fD3PmzBkrjdXUeEoyHh1x+/bttt+TU5ZThNB0OjGdjlXED4KAuiyII4+40yGMY6I4tpqBbRK3lBlrqyOwzC9rEqDvSY4Wz9qCYbmQIloGYmxyaWfVTt8yxlCVFboNFr1OBwTM5wlZnrO5vs6VS5dZGaws7R6kFCQVlNrK7CySJnPCvqFpGhpHMC8zdg8Pqat6WUXatoFACEspV0qAhMjx8IWkMQvLd2EJeUKxP0rQpuHx7U2+713PcHb9DFVZE/cGPPHEU/S6G+zcHjE82MN3JKYpub13YN2iJQSeh8R2a5RjCTSOlLhScenCRR5+6OFWci22liIoet23Tvv+C1GN8jwnyzIGgwEbGxs88sgjdDod2+B3JNL3aKTVqMqybNnkXmy4OI7pdrvWuO/wkMcefZROx8IGjlJMJhN2dnb4+le/zItf/CxvfP2r7O7ucnR0RBAEfO3l19CNw3SS0+30eOqpp+zPL6vlIGtd17hOOyneNCRJwsrKCr7nEccxcRSRZRmOY4dFLeSUMZlMlkOvnufR6XQoS3ug7uzsLCtBIQRFYUVA7cF4OllbxkDTGOpaLyWfFodzVVXLILTo6yxeq7pmMhtSpxlFkTGfTxAV6AqKsqEoSmpdc3d/l7opcHyFpiavCoqyIYj65NmM0BM4rq1wQNMdRJSzCZurK2Aa1tb69Hv2oOt3Qi6fO8f57TNoI5nv3cCpE1wVUCQps1nKxvo2dWVoGlDKoyptz+TNW9dIREMQd3FDh4ceegee20Hr+kQAPq6QFtfhNC4vCHBDhQ4URW8AwsULA4yS6Ka2gqYVx5WT5xJ2O0jPRXouynNxAh/pOiBDtHTQUlEbcIKAynGllEcAACAASURBVJR0B1uEccAv/N2fRUlD6HbxPRfHCTBlhS5TJODLgMDxcDG87amnMEjibp9LDz3SOggHUGswhpX1dYy0iZwfxdRVgePIpZOtki5SOrhugOdZR2mpFL5v3W4d5xjWW5wVi/6YZZfV4JxOJEIKQZqlSzktOGbm1nXNbJ6wc/MWyWRKXVbLpM3rroHylgfxIvja81LT1A11XtILY862Ls3LRMvotv8Ws7F2GUFIGAf0IthY8VGufV8cR6yvruIFIbf2hxTdPrOs5PrtXS49/STv/64P0FEhr73+ElWd8a53vpOzVx7lIz/+76KiFUohKcqCQT9ktdtHNIa6qlgZrKCkYnWwgq5rsumcMAzZ2dlBa83a2jq6EYxH07d8He9by04IgSuPGWZoQ54mdKKQtZUBtWkYjcet22dlG30nBkgtzRTcwLJlNlbX6EQB2+vrdpalyRFomiIHB7Jpzu7t28zSBCVddO2wvbHGgRxyNDrkjz65y+rKOkHoMyvndDvrZGmB9CyG7uCgy4bQdUh0RdiPSaZTbu3c5csvv8r62sryJldVxcHhHmfPbSMdxXQ+s8ywsMvd8R7SdVhbWyNLU4bDMZ7n0OnEZPnMej6d0rWAco4n4c1yMv6Y6GDueb8xdlpe6nqZUNRNQVk1CKyT5QIKy7KMIsvtYK3rInVFNp8SqobId2hqg8AhjCJWVgZYG/rSyj0NLI1XOdDrxQwPx3Zg0nWpck33wgZJojnzwAXk4QH9/oAyz0mSuQ2cUjGdTomjHk4QUTcOURRy4WKAbgTGKIyxyUVd18vM8hs/82lajufTVIqicaijTTznGGlQiKWlyFIFYOkEqpaVxYLIsmC2HQ8BS6rK4LcqCo7jcP3WLtLzQblEYUiW5zRlxtVXX2FjZYDGIFzFA5cv8d7v+S5+6zd+nfe/6x3EcWhFNdv/2Ri9hK7DMGQ2m+EHtNe6aasiARwPJdtgY8dHliKsbVW1uE+2irJknNO6jABdl1SipjaGGoU2ipWVDlL2yLKCyIvYO9gnF5rReMyFMxt0HJ8sGxFHHfqbLo4vEWWFDjS1UXSEi/QV270Az/f5w899lrppOH/uHJ3IJa8aTClIG3AH59F1hZYpdVmgjMuZrQf5oQ99hD/4w9/hcHhAt99nejjiyvvejZjOODoY8rb3fidR5DM8GEGR80M/+qMc3h6RlTU6r+lFERqoiKnqHC2hbjKmyZim9ij2x/ih4PoLX2Z1RfPa1V2efGSTPPOh6XDz1u23fB3vW+17UWJ/o5LtopfkOA6Dbo9up8t8Pmf37p17MtFF+V6mOd2+T8cP8D2/NRYTxKFDPp/ayqRJyeYT1jdWWJcrzOcZV65cxtAwnSWMZilFlbK/v0+v30fWMbPM6paJQlO51XJ2qBYKL+pyfWeHG7d2mCcp22e26MZ28jvPc4qiQAjB1atX2T5zbonjTiYTtra3GU8nFKXtLcVxTKcTLavFNM3u61J+u9aC1LB4sBf3SmuzTBJOHsxWJ01jGkOZZwSeS9OquhdpslRmdlyXsqxwPY+yanClIUlm5HnO6so6STpj/cwaum5YXd8i8iPOnN0iDGK+90Mf5mh0xOF4aPfLYEBWZIRBj/nMwoPx+joXH3qSzSsPsX/rgHx0yJVHHqXIc9yVNe7u3EDriiwtiKKYLBM4rg9SYDRMJiMQZjl8uVCmP+nkeVqXkgppJEUN4WALL3CRbqvO4Pstgw5boZygdi8+1zEaYVmRTaMtTCckUlhlBy/w0U3Jpz/zGSazGZHwOHPhEqO9A5RSdHt9cDzCTpe402FlfYPtc+e4vbNLN3aJfY+qbPADD7EIhkoi2uApMEu0QmtNEPj3DGXLltxkN5xBSOudJlty0OIzAS0xQ9E0x/T907aM0RwdDTFVTaYrrl69agXupCDPczSGN4zAlQKpNFvnLjCdzrh5cJu+bDgMPQ7LiqNQ0Y06TPKKuLvGpctP8ewz28xmM6Iw4sFn30ujGz7+8Y9z8dl38PxHzvLpT/wZ3Y3zRGGIkoLZZIzf1Py1n/55zmyeo0gOmc+t+n2apoS9HjLu4CqfSXqE63n83M/+Ard27zCbHKFUzPXdz/PoY0/SiTZw3IIkSRgOh4QrfUqjydIM6bj0V1e59voO49mIMD6DERnb5zb540/8KZeffTvXrr9JKqO3fB3vU1zVLKudk/7xiybmIgM3WpOlKVEUEQTRifkjTRzHpGlGtzsg7sRcvHCBbhzieY7l3iNQUUTjOfTo0g17HB7us79/BykF09kRSnn0+z16awOKPKcXx4zHE5I6wfEcNA0raxu4nocygiLNuHN3yOHRIUfDIZ2VVaKgy3B4RF1p/MClqorWOdYOH25ubOC6LuPRmHGaQQGba6skWUqn30VrTZrm1LWm0+nh+acT2wazPHxPau81zb2H1+I99oATGCOQTU1ZCrodC70ifRwJha7xPJeqbEA34EmE0yCM9YnKMusAOxj0SOeZ7XE0GXl6iMdFor5HNLhAklc4ykIz3W6PJi+ZZylPP/00/X4fUWZ2vvJ8TGdNMRwXRKHPwd6e3X+mBqFxPZ+7RymbnQ6e75DkDS9+5WXKcoZyDFqLpcpGURTLROrUHm4YclXhul0euXK5rWI1cRxgqhq3VQopmxIjrbX8vVqKpu3TWBM/e88NZZVx7fXX+Ee/+qtMZzOmkxm91TW0FqQ13D3KefDSFcaHh4znCa5bkkzGBGHE8+9/H//Hx36bV158iY/+xEdoELh+QCMlUbdD0Ints2fafYYdAVgkhE2j2z7H8fyXUMfyQdAmTqhl329xxtR1be1GWv+k07jsueGCVBgclB+iEARxRFVVVHWF6/mIpsZxGuZpTi00lx84Q1dU+F5EMx9xZn0FIQMC7TFOG25OMy49dQ7l2xksL1DM53OuPPQ4z7ztvfzmP/lvKdIZ3/+hH8b3LcOv43o0ZYXnR6yvrPHKl9+wLQzXRShFHEZ85cVX+Bs/+dc4GN/kzz71KY6Ocvr9dV588xp37u6AqlnRHqK9n57nkSQJ5aDHJM1p6oa8asiKmkZAf22NO7fG9HqCCsPb3/UcN2cTVrbWuXO495av418IsgO+CfpY4NlWN8tlb29vYVfFwjLaiibWdLtdVjod1gZdTGNN2RzHIY5ja/nb2KZe6Pp04gjPs98DmEwmjEZj9g/2KZqKsihJk9RmIdJQZhVal4yPJvR7fYwxzGYzsrpGui5V0+C6LmmaIpVzQsk7Yzqd0e12SJKE8Whse06+zwMPPEAQBFy7do2w7T3Zy2Ex4k6nw2w2v69L+W1b34BpA/c81CetpRevpZTUxlDkBVHPJ01TezA0BU3ZoHyPsiisqm9VIk1AXduGe17l1uyrLJlOpzx47gKBI/jn//1/TZmNMPEV/uZP/yh/5cN/lXPnzzOfDu3eUZJpktDv9VhfX6epa0ZHu3zqM5/gXe/7Cf7xf/VP2VqdceWh53jw8Ss4cp3pPEfJkqa2Q75VVYEjGY3GjCcTDIaqKhHi2OX3JNvutC6jNaJwcGuf1e1VIl9hJEgalO+ilG1qu6qFthpxz/1bQFuuq6ibHE/5vPbq1/nFX/gFOw8orNinkB515VJqw3BeEYiMw8NDzpw7y2R8SFEk6LJGmIZ/8S9+g/l0Tuz6XLn8EK7yqTD4UcD61ia+56GFtSIQQiARS1WChdTW4tov523MIsg0gKXmOy0rbyHMukBUFvv0tGpGLnrKgeOiG03kh1R5sWxt5GVBVlU0RU6RzxAyoBO4TPdvcfnhS2gc3Am4wqEyDjLcYLvv4gUOL335yzz33HOsrq7hOA0vvHCbR65cpkvN8+99L489/hidbmiTwaKg8RTz4ZhLl85SlA11qTl79iw7e3cYjses99bxHJ9HH3qKT378Jrdu7+Iq+MQffYHB9iqXHjxPoR0qIRDScgDmcwuRj+YJB6MRkoaXXn6FPz064OKFK1x9fZdOeAY/6HN7/xZPPfQE+fiI/YM9+hsX3vJ1vG/7ibquT2hRiSWBwPd9JpPJUlhzMciXZDlxHC/hocWwaeQpdFVSFQlRFOE4jpUfUpYV1DRV26NQrcW2Vd6OwlZsM8+5eWeHNEm5e+cuSZIgPYVAUpaabthFGUHQ6zBKZvhRTFWVOIHtJaRpits2HLVplvMwcRxTliWj0ZDV1VXCMLRMuzRlY2PDqlN4HsOjIXlRLpuQnntKnSxPrEXP5xvXAsaCe/tNTVMv79uiojDGYGppm7CNzYTztMIJfaqypGk0nttFCMF4PCZ+5HF6cci73/4kRzdf5nevzvhH//h/JC3ggz/yA0sCie97lrnVSt589ZWv8Vu/9qvsNpp/9tsvcTR+iQ8/6/Pko/8+g60Ndps9+iub3Lp2gyS1vlej0QjXsXM6RVFgtLF6aLpZHnKLCn+RRJ3GpRFEb38XgzPnmecJ6XyG9JzW7tuqrCulUIFl1ck24AJLRqtur+s8mfG3//ZPUSQlTelQG2iMRihFqAyNrpjT5cyjb2f/5T/g8OCASZpw6dwlXEdjYnA9D9f3yepDSg1R1EVKFz9y2NzexguDpTmdOoGEep6/hPaBJT29qiobaIREmHY4FNMy/Y7JGieT3QXj7LRCrVprsrphVhSURcZEzqjrCj+ZWtkrx6GuShwp6PUG7M9m5LOcQeDxxtXXcCKPceUwvJYwTTx+/hd/jNlsxIsvfYnveNf7eOihS237YMi5c+dYW1vjYx/7GD/1Uz9FXpRLaD4MPdI0ZbC2itCWgffgU09y++4r7N0dEvodtCmo5hWraxu8/bs+yCsv/gnZvOR7Pvw93Lx9i6Kpeds7vptP/skfIbQmLwuqdoynKHIG3RBTl5w/v8b3fvB5rr/+Mk898Tw3b14nXOlQ7mu++sqXcfpbFLXkcG/3LV/H+7MwpzX/ah9ky5xRHA5HjCbTdprfQyNwPL/FjoOWvWU1tyJPEYU+K4NVunFImSU0ZYl2rC+P0KW1OjYGty3lfS+mrmb3bM7pZIKjrULCPEspa0M5zQjjmEYIRklCLRQREAUxs8nMVmpC4QoYdGzgmbesOakCwlAvq7zdO7dYW1uj318HmuVDVVc1vW6POIpYXVlHa8P169dZuQ+u/bd7nYTkFlnmyQf7G2EQYwxaCLSpoSmoGnuv89zS86k0NFYcUzk2wJVlaYNdUVHX1lCv6ETMypJX33idH/nJv8n/9s//JY9sHrC62eHmjdcg+dCyyizzgjLPubh9lmk25/d+638lSR0uP3zEH3xe8OSlB7lw4WEefPQyO/sjRgeHNOWM/mbE5OaUNCsYDEKKOmM6njId3kabBildjDk2lDwpNnpaK6Uoinj3h3/M7lfltHvSBqSyrlCOQkoFKOqqompSdNPQaGvlUDcVjW743d/9v/ijP/k4ulG4fsQsmWF0iSMVRggwPt1Oj+Rgynt+9lf53//BF3Hmu0zqiteylwmDHhcuX6RpKtJhgislysMO0IqEwBvQH3RBLxQGFMJZVOE1jutT1Bmev4It2vSSum7fb1UJBK0UjjEIx74P5D179lvt29O06rpmMhkihNWci6KI0PPwXRuAdVVC06BNg1Iem70+jgZRl1w+/wCVI7n55g5Hw0MuXXqGqy+/xvPf/Z189/ufJ53N2pEbWgtxzfr6Ou973/us/mRVM1hZYTgc4rWD046ypDHP9RBC8ulPfwJtIvI6oywCet01yirl4sULdILv4trVr/Pa62+ysrHO408/BVhx3sPDQ7RjqzzXdZfMXE9I7u7c4cYbN7n4wKadozKGSDo8cu4CF9Y3+NzXXuexCxcpioKjtxiU/kKQne/7VFowGo3RRt9TXmut6fV6gGX6VFVFGIatmi1sbGzQiUPSSUJd5qwNejRNgR/00LrGWt/aymuh+bSYr1horEkpl6+3t7eZJymj0YykSZnNZrihj1KOnWlq/X+01kRRtGzuFYWFCpXj4UtFELhUxqp6T6fT1juoYHVVopSt6vr9/nKOxQ7LllRVxdmzm6d2YG+xTvb9Tn7tZLAClgf34vuLRvliTqRpGrQwKDSe6y3vkZYg2usMNsjlRUGRF4xHmtuHh/z0L/4d/roQ5POCj/3Ox9jf3aGQ1muqriwBpWwK9l+/SX+1zzMbb8PUDR/9Xvgr7/9eLj/xCFff3OPWzZs0RdpW3P7yd6uqiuHokCyx93dRfS2SjGXv4hten7YlpMRR3rJXJB2FUh5aSrwoomkMLN7jC4S0z03VXsOiKPiHv/RLHA1nDPpbFEXOdDKzQ6raxQiBkg66WVS+GUevvci59/x1jj7+3+FLO38myKkqbcVwe9K6QBc5VZNR1wbHWcMYwNRLMdC6rpFtkhEEAfNkjIhqjLFSYSf34GI4+RsDzWLfLaE9WFZLp3U5StEJ/HZfWcNOYazCjNc64laNoRtbvzEhGmsXgaCRLl94+SoHZUkQhRwd7RG4DkI3NFWBq0yLGjVo6S1HbLa2tuxcXhBg2llOr1XwqEpNXTXUWtPpdHDdkB/6yE/yhS9/kcO7d3nnu96G6xs6cUj4wGP0extUZU1S5qysbpKnmrgTtzNO+h7YdFForA9WeOc738MLL3yKF774RSaTEU2lOZqOWXF9FA07t25y4cK/JchOSsl0nnB3/wCEaE3aHGvs1R54Va0ZjWetd45sm9wZ3U4XT9lM2O126K/2cAQMVnrEvkdT5PZQcX1MXeG6HsaBPM9QTUE1bxBSEIUD0irHi2Kqwynzec7RcEhd12TaQnKua7W7jLaZu7UfXyVJEoqyYuAHxMqhaPQS4+31usyTKbOZNQATjWYyHnP23AV6vS6z2YwkSVpbimO14kUwzrP8vjbwt2uZdjD2JMPupK7bt/w33yIzXSiC2+9pq3cHCGETB8dxoLWotv9/69PS7eA4DncOh0g/4Nln30Zvw7BxYZM3dm6zuXVmKfRalSU7u7f40p9+mrWNAe//8LMM1p+jTHYpa8Obb9ygqUpCR1IaD8fxqVDLUYLRaMR0OmU6rsiyDM1x5beoiBYD1wsF7NO4LCHARUkP0/ZUUA5SKYwwKG9hptPYJBHX2oNIh6qu+Ie/9J9yZ39sZ4q0Q12nZFlqWXquT13baiaKLHrR8wV/8M/+I97xAz/NDRXjqAxX2oMtCjtUZcM0nTKZjDHUeE6XwAutgWVRUNflco8shWxNm4E2Jel8ghAustXTW1TFi+B0kgKuF51nafX66vreHudpXUJYF2OllA1ExgoJOEGroKGENeczGikhExqEpjGSu9MJ/sYW1e4dRNNAnTEe7VCXD5PODZ2oh9E1UkC+eNawagm2QPBaklWK63ZRysE4GowgSTLCMOT7PvgRPvKDP86jTzzL11/+Ih/+8IcIQkU3DhkOa8LeKs14gtKQFw15XnLr5q1lb9ZrRX3LsrQSVo5LkeVk8zl+4PPMM1cYjYbc3tnhaD7hjz/1ScLNDSrZsHN45y1fx/tW+15ExyzPlxtQt3LxC68g3w/azFpTVwUrKyt0Oz2yxA6fep6HxhA4kiiKltG3rmt8aWFBXedoBGWSkiQJk9GYg4N9mkZzfecmk8kUKXxWNzboddeYzxPOnl1nbW2tpaAXDI9G1rq6ZZaNx2NWV1aXlVYURZTzlO1V+28yZbP1+XxO5LnLLD9J7p0ol1K12bVeShOd1mUpwotGd0tIwdJ/a2OhEbvuNR20ttZQl8deUI5SiIU1cqNxXGEPI6yygzYS34swRY3JK0bDoQ32UYArNPNZxvU3b+K7Pn40oBsPOHPmHE3TcLS/T5XOmUympFoTxj6eWWU6vsvenUPW19dxlcZVDkLE5Lni8OiI8TSl18KvQQB7ewfcuXMX01pl2IxOLL2EqqJEGJYQxGlcRoDjG5TrIFvjukZbkU7LRDuW1VHyuMKoTc3P/52fYz7FHnzUTNM5pkqhrvHcEBl4qLLCMZZ04PkS4a/TK+7w6u//Jt2ti6i0Rzqf4cUbfO2ll5HuABlkPPD4exh0Y+qmBBUSdAZWzcEP/7VJzmhUEsYdhHComwXLk5bIsHBatvvTDjBzz9DyIlgtzCFPL6kB6kYzz3M8z1p766aho8O2Im9FjqXfkrZAGkHulHz21Rt0ux1EXWG0pDYFw+EdEE0rS6ZB2D62H3VxnS5CNiAsBGp0jet4CKMJg4AoCClERd0UrPZjyjzlR37i32Pr7BZO6PD4449jmoydmzdIRzN62xcZ7e+R5a0XmdBIoemtRFQGNjfWrGQXDlFgzUod37MIUZHQ8WOKdIKpMp599BFqDNQNX7pxgygecGf33xLLbjFDUFXVUmnWc12Msu6OrqcQrSI2TUO3E7PSjUiSBGEqIt8hmc64ee0mm5vrBL0eyolRykVKg1QNlQBT1xRphnQClHCZT1PyvCLLKvt/1QahFaVuuHPnLk888QRxHDNPZ+wfHDKdzknmaauRZpV39+/cBWEodYUsIfIsHtq4DmVLwvCbmqasCYBS14ynQ0xTUlXOMqNWysPzbPmcFXPKpiaII6tefkrXSVjOcRw7HwFg7iU6nGRoLTLexaFt+2zHbLXF34uM2GATiSzL7KZ2HaIoYjabsbW2QpZllM2QIPBQymV9a5PuoL9scvd7PRJTc3h0gJSGIPIYz+ZokyCEYDQa0e122dvbY5YkZGVhFYZ7PQ4PD+l0Ota6fmWFmzd224pIt3BtC1kuhoOV1Q47rRCQEBLpBDhe0A6Sco+80snK9WTj/8tf/RxZAlIoqpatKqVkllnbdj8IcHyXBkmVFwRxH+G6+E5ApzMjS2rSwzfYPPs4l7/3Z9h++L0c7t1gZe0iNz/+a7z9Ax/l6pc+zv7eIZtr68t+8qICv3fY9fjvpXzQUu9RISXtsKxtvNth32O47iSMtyAznOYe0iJJcHFxpaCqaso8pQ5DFq6wC/SgqEpb3UvDfJaxubnN/t4+ju+hEJiq4Tve9W4GUYfY9Snb6xSGYYtSYPs1UcR0OsUPA+qqIYoi4Pg5F6JESsHa2ir9fpcgCOh0Okjho6ucQAXc3XuZBx5/hOlEMJ4UrebkETdv7vDVl18kin263S5JkiyFiRctFXs/jlEIz/d44aWv8PATT6AwlOmcbtjFO3uWr71x9S1dx/uG7BYaYr7v4/uWEoxRS5vvpszZ3NzE9VzyLCPPLZQV+D6DXo+J51O0fjeLYVpFg5QGx21LXt1qOJEzHo2Q0qBNhRAN2lQ4jsvqyiqbZ8+h2l5SWZZL6CbP86VS9+L1dDpFOZI4jiiS4yHWTqezVC1QjaEuSyos/qrUMRa+eOC0trp9WmscYSGGpqw4nd2Ib151XSPbg2ERSL7VMi0N9yTrbvFnSfBYeCFpjRa0laJlRepSU5TWZ6dpGnr9HlGvTxB6COmSzxKMtP5JxhiKNGM+HBFFAdO5wvMctBH4rsPhaLLEy6MoojaaqN+l1+tx+/ouq6urJFmO67rMZjNmsxlS2Arg5OHYVPWxBh7fTOY4LUsIgeOHoFww93o5nSRlLFiDi77fr/2X/wTd+Iwm1xH4bGxsMEtTjLYDwp7b9o8cRak1KAcvCHCMx2DQR4gUlYyY371K+sn/Gc8Yzr79eWodEtQ3+cJn/m82lOYrX/kqD195cPmzF0FxSVZoV9PYQ9LaJTRIafeN0fZQ1QsTQSPAgNbHClwne38nR0xOa9/PYDAtG1VKge9KmvLYGqSpbVBtdLO07amVIM9rHn34HKPhFD8Kif2QRy4/yEOPPYrfiajRy+sspUQLQVEUaFPgh95yPyx+TpIkRGFnOe6yutLHc72lBmIYhoRhiK58miLk5q2M8XjC2toWe3sT1tfX+eIXv4iUhs997jP4gVyiWifX1sYGs/GEsqwQrSFfGEY8/vCjNFqTzRMixyFQik43fMvX8T4DkljCU57nL2dvlJR04ojNrS2KbEqaptQFKNexzUxs1heGIU2nJJlOl0ZuQRBQFwbHsb7zynMQ2iCMocjmzGZjptOplSFyJBfOn0U6IdpIam2Ie1YRYjKZMJlOmM0Sa+wXdexskjFMJlPysiTyY0xjfUQQAtXi2GEYcnBwYBlNUqICHw8wKKRyKFvYSkpFXReAsdTaWrSZ0b1kgdO2RGtpbL1TjmWcaGdGaA8sDPc43y4ehAVNt6lLfM+Blia/yGQxBqENUtBal1eUecL6So80K3n1zTd59onH6AUukedTGYFoHHReMNMlRZkx3DugbgoevnKR1X6XKk8p8px+b5ONFU2WpUjHwTSG1dU1DodDDvcPuXnjBkWeEw9CDvYKptOSeTpDA8JIaIUrhRA0RmPqyj68yFML/wB2r5UZWWYVz6UM7qF2K6XQLdQlZMUv/t2/hyMkB8ObGA2Ooykrgy8MWWNwlKIoM6JOnzyvkEojdYojYpRrkDomjBwEDnlR0PEm3H7pdyi6DltPP89InUG/9jm8rfNUvTOgmiXs6Tjeif10kkCjwHSo6hmBv0LT2GuvnPaANbJ9X+smf5LAIKBuxZzhWBnmlLq8APZ5CQMf37H9s7qqUMoagtrPJ3CUSyUsEWg6TXAcl5s3b/LUU8/wzvc8x4Vz5+hFHdw4RPoe+B6ugbKsaJoa5TlgNFVdEeAjpAKtqXVN6HrM8pS6rjg4OKJuBZB1J1xKTRlj2D/YYWttC+lKBitrTEZTerFHv9dDIOjEMf/qf/lXaF1S11Zb1Pd96qbBde39cj3PnoGtfFeprcqN0AbfURgkjoCmKlD3cdPuz8LcmCWjw3U8OnEX3/cY9O0w6XRyZG+MOm5YNo1VBs6ygtksodeNWXvyMfb39xmNh9y5u8PW2grr6+uEYYjITTtv4VDVNVIpgjDACa2a8GQ8Joys4Gk6m3P9qzesNxM26AVBQLfTYzpLaFq31PFshnYlcbdDMpvR73TBVUyTOZ4+ZmRlUqMl5LMChabUkNcNW5tbFioUBV1s0AAAIABJREFUEsexEigCgXCOD7X6tGZu5htfn2wSW3M0+9os37/IeHXL0FkMLi+y3zzPl2X7yQzZWk8fmxqWZcXa2hpPPv0EZTZHuh5hp4cy8Obnv8ajF89TNA1HRxPSbMwTTz5Kf3Ud0dSEnsK4HtN5ihv4NA2MJ3Pm8znT6Q5FYeHbUhvmRcn49qydx4Ht7S1mc8V8atliRhzbG8AxlLSo9E7dMvD6G1f5+//B30M3ltX6n/3nv8rTTz9tGYntLKBUmvl8zi//J7/Mm9du28xXa+qqQgqFH3gkE3tQ6KbBcwI7G1SUNKVgMpnQGWwjpUU4lFJEUUjdNPTDkHk5p371T1l9/4/S23wYvfcqIsvoDzqYtnJbMDJPwnMnqyQlJVndIPzjZGjpKOzc69p7MqkTQiwp5BiWFcBprWqNMSihrbafkUuGZ92U7e8uqCsBnsIIKwis3C6RhO3tM1x44BKXzz3C2XPb9HoxeT5FIGkqjRLW06quGqpKo6uKymiStMKZH7H6YsXsbduMOlYpfP/grmVbTqbQCdDGkGWW3BAEAXUTMJnM8Z2acxevcHd3AoFh0OlZ6aNZwnB0dznS4foeTVXTCINUEpoSB0vcqJoaXypm2lbp4zxnvdNlbBoqNL4jqeVbh1nvu4e0GHrt9zv4fkCaJqRpumRaLbKmRYkp2hJz0agsioLVwYBOx2c4HDEejzm4u0eaWrWFs5cutDLzHnmWtJIXHtlRis4ML7/4CtrReL5HWZRoFHlhmR/K9fDcmCyrcRyPNLGV2GIgL00z/BZW6HY6VLohdALu3Lljs32hllCfIxVZVnB4eIBqS+Jer0e322E2m7bsumN8+zRXSIt1MhhZCESx+LVPim8u4BGw2lcn6dM2MIslnHKS7n/ya1mWkWUpt27d4tyli5zdXKeoDaPpnG4nZOfVr9JPR0gMn79xm0cefhBjNMoL6QQeke+QaxBOQZbNmKYlg/UNwm6P9Q3DfJpYRl2akubXGQ8nFOWI0WjI/v4BeTHGNMdw3cl7tPisC32707YaXeO4AtdT5KlVav+VX/kV1tfXl9p/eZ4zTzPKquTg7l3W1rbvobrXdU2eWTZhWZa2em3NGQ2tRFS7DwaDAQcH+wRhwDzLCOKIJC+papcoOaIfODz4xNPsXv8j8D1W1wYoh6V9+r+prSNV62QrBN+IDy8r7D9nLfbbaZZ7OgmrnmSyLgJpXVcIJTECpGP7mk898Qy3b95YDuUvEKMwDME0S4ULoxy0NNQI6qLGrUuUdkiKPb7/GZ83X4Doa3Nmb+swLufMJwndbhfP9ZakrizL8H0fIQSBHzPPZqAzlBuSJoeEfkldW6bz/v4+d+/exXFctLaJR6M1CEGjGwLXYWtrm2SWLBOMuqoxWuP7ga0MW4UNIe8PZr2vgFQWOQ9evoIxkvl8hDAFjnSWHPjFDVn8Xde2OtJaIwNLF47jFbQWdHuruE7AWn9AL4o5ODigKApuvfEmSinbm+J4pmXn7mj5cMX9DnmSIpWmF3XoRV2isIeKO60Pj50VqrIUB0PgueR5gy4rCB1kGCIdj07cYzIa4fqW0thUJUWWMoi7TGcjIj8g8kL80FaFR6Mh86SgLCvOntvAaWoatM1kmtOZuQH3BBjgmyoksPTtBaXbGI0Qsg1WJ/XvjjfWopm9CHKLPoYW0FQ1vpBoI9jYOM/+7h5PPvYIoW+rp8B1+ehP/DA3Pv1nFJlDMDmiZ84ReQ6+AwbNaDbn4K4lK/RWuzi+Ic1K1lat2rqjLEOsupMRuBB3fNzCbXuMoGplHyJ7BVpY6F4F6dPaIDdAJ+rwN37ub/Hr/82vU9WGbickKSEUDrduHwIghIXNQuVTVBlNVWKMZV+VVUagFJVwkUYjBWhjqMocjAblI3TF8GiPqrTze7OpRAoXWWuS2RzHccmB5PAWq9sP8eospSxrDnaHeAQotTDiu/f3v7daUhg8GlOBUfdU2idJEN/qXizfd8JsUcnTqa5hfcHEvdJIHH9GIYXVuZOC0XTKma2zvPNdz7Fz6ybz+bx1RyiXifvKytpSd3GeJIzHVo1kPDnkuSc22L27x8aaYBJO+Z+qT/G39HeRjD3u1AV7e3torbnwwMXWDNXF6JMGowFh2JBlY5QbUhQZQtqZyizLePnll+0zXdctI7IlrTS6PS8E48mYJE3Zu3uX9UGf8WRCt9NlOp3ge92W9Rown2f43r+lHtJgZcDVV1/m7JkHlk2yk6KOTUv/XtyMKIqOGV7Cvi6LgnB1DdcT6NpQlw39QYe6KTh7bmt5WJZlyf7eAcZYCM+PVkjT1FY3qwH9/gqbm9sURUkUxjQ13D3YZzabMZ/PyfN8aTeQpulyk5RlyUrboGuaBi+OcKOAuqqhtNnMdDrF83zmacF4MqbTtWq1eZ7brFAZjg7HVFVJFIZsbm0xn711z4+/jHW/VdxxE1nfkwEv7vHJ4HRy4LTKK4wXol2Pdzz3Hg5Gh5w7/+RSNsr3fXr9HhsbK7z2Z19kPXL54Y/+VbavPMLGmfNoo5nPZxRFzebZMwjA8UN8V1CUiR18di0kfPPmTW7cuEFd1/R6PSbjuZ0i9zzS7HQGm7eyBHbQ8t3PPceVX7vML//Sf8EkGdN3HIyrUMpWro7TUr/jgCAIGKeJHS4u7aF4eHRA0O0gXAddVRit7R52vCXrMM9zLly4gBCCW7du4Tkus+moTTIDPE/wyotf4OwT30nirTHwCl5/8xqlfmvIwAIqdZRC6+OK+uR82+LQXkCRlmxz78ycFBKh7NdP61p8psWq28FXIRW6MYwnY9bX1wn8gOHRiDCIuPLgg9zd3UUIQ5bZebE4DhBIlHKpq5rD4RGHB0fM5wmTyR263k0ee+wCN3aucjG/yH/4U+9n8umMr8kx3cZBCbOssLvdmGxeUuvGkn2kxHMjlJJ4ns9kOiQvZszmh8wnFVIpXn/9NRrdtEonlhtpjUwsUSjPc0skmloOQRx3cEZHluk6nOL5PtrM2vlC+KbS+N+w7isg+b7P+voqWT7DcQZLGqDrBoBVzcaoNsprytJG2IXe3Xg2Y2NljUprnKpASHBdQVHYklVKSRxGdDoxTVNw6eJ56sbQIMjygtk0ARSD9T5aA1ohREbVGEbjMXt7+8xmU8rSGuctqJJJkiwDm9PStx3Hodvtks3m5FmKrguSzJasYRgyz6ZIR+IGDkJWdDt9oiiiMWCkodYGRENR5Vy7dh2lvD/n6v3lrZPT7ie/9q1VG+6tpooiJ467y8ztZDa7qIAXmZf928ENO/zIh36Qr774Mlk+5R3PPmOH9pTt8TkavE6Pd//YT/C53/t9PvCO9xGureG7IdQlGEkYNGhlH3Dl+uRFvYQ/irzg6OiQpmlYXV1ts1JJWVhotShL22sxLWysZDvjci9h47RCdraXE1Hohs1zG/zT3/wfOBoO+b2P/Z98/gsvUDd1+54ujdZsXTrL3Ru371EkybOcJEkYbG+RzEecVOo/yZ5csKesy2dElSSWth/4QIPrCd73UJ9ZDOfOn6cc3maazDFvkQ8ihJUFsqSE4J4RBDiupk4q0X9jtbQIUIv3ncp1sveKxXYMgrzUpPMZBsPqYPD/U/feUZamd33n53nefPO9laurqnOenp6s0SRJIzEjIWlAyEJgA14brYzXwgHWmBXpyAaJ9Vm8aMFeRLIFLAYMKAEjJCSE0gRN6OkJPdPTqXLVrbo5vPl99o/33tvVM5LoZtdS+3dOne7qul1V903P8/v+voF6rUYSJ1hGlsSPOHToKHhdMraGpiuCwBuYsXrpNRqHnHn+FI16m4xTwK02+fMnlvlE8t/46Q/+KE8+eYYbDuzC3WWwr3eRuVsOcv89N/NHf/Q1xsfuxMlm0WSWRn2LXq+DaWm4/ZA48cnmMnS6dXRDZ2nlIgWzzFp1k83tVZQcsDtlqlkMkgAZJyRCDCDHGNPS8VwPTRPEcQgkxGIgChZgGBa93qsZet+srpn2fd999/HZz36Wfr/PzMxMqi8JEpIkIlEKTTPRpA4MIaEkHSwrhevG+BmfIAjI5wrEiUDXFJOThdH8ydJNIEFYqc16v9+n3u4SRWEaFWFlOXfuPGEQo2sm2/Um8UAvo2lyMLtIdRe+749gpaFmolQqjZzHHcch8nx6vRjXc1GKUasphMC0jNR/zykQRyk91ev2MAdRyl1Xoxe45PIWtnV979zSP4eO1+m/pw+BIQSSXLEYjeyCAKmnO9QwTNXnVjZHFEdpiN7Qw05qjE3Ps+/AUc6/9DIvPv0c9eYqxVKR5557ln3759FNCyUkyrCQwqQyPU3p2FHM0hh2JpMueJqGYRkkQYSME3zXo9WtYudKbGyvk8uWyGbyFEtjuL6HZuiDmJAua+tbbG6sokuIlUTXB4mdyaCrC9OUzUQlVzjXX38lsMwcRpL6FsRxTG42y/v+xftApmzBJI4RwgSlsCyD97///UQ9F195KWVfT1NyqyuLTE5O0mq2QCk0IYkGdk+6paMRYkiZPjSjcERmmZue5X/9yZ/gxK0388yLi7z/536S3vnnKUyOk7evNHT9pu9ECGzHJgg8dN1EJRIhr/Sm2ymqHXZMqduDQskrSTbXqyHu8DzFcYwu9EFCs0oNfgfxE80oYmpqina7zdzsHPXGFucvnWWrusnM/AFyhdTOLJvNjij01WqVVrObUrr7DTzTpbR3H/v3vJGZbI7933E7z7zUZDuZ5/BtE2zXtpjSNGbcDcwvf4FwYRZt9laitT7dVg1NE5RL46BitjfWSTxFKVdGR3Dp0gqffPgviMXl5NqdfyqlkIlCR2CZJuPjE5w9e3Y0owLouyky5YfBaGxzLWzWa+K9SiHIZTLcd/fdrCxdpNNsQJxQLhcplYpIqZPE6rJ4StfRTQPDMrFsG8M06XouXhzT6naI4mjQ1oImwTYlUpdESUK3lzo1ZLN5Zqdm6fc96vUm6+ubBG5At9Oj3uogZEo2SJKE+sBCyLbtEaFiqIMaeuClvk4p6cJ1XUhiHMsia+dGavDUBt8gjhXtdpdWo0uiBF4YoiTEJCQodDNmemYMTTNQ6vq8UV6ZhwRXkht22gQNPx/uVFOoJM2oCvseSIE0dLzARwnwoxCkxM5kuOfu+1BK4/kXnuLgoXkuXDqDFoPuCXLFcsquG9CV40TR7Xs0mmlbv7a2RrPRpttxabb7+An0g4Bmt0/H9bCcPM+fOTuK+giDgG43vUlLxQq5bIF+zyMIfRwn7dg8L91pDiPnhx/Dz4cEgOu1dgqQdV1HFxINUFEMYYwhNGxdw9TSW/g973kP2WIBzTLxB9DXED7v9XqjRONksDgPHxaGobO8vEypVCJfKOA4DgsLCyhDcttdd4KCL3zi9zFrZ8hntJGIfBhHcDUlhXwV9DusV9pZDYkxw2MwXKiGf79uO6RBSSlpt7oINEzDvtyJDjrQarUKSuF5PaSEWqNKuVLCtjNphxqGrKysUK1W04DTtTUmJ2bZtWuGyalxxsbnGDML3Ln7drqrRZq1iCCIaTc9/uIzFxDWvXzua1Um9h1gShqYn2vxlV/5HELF1LeqRIHLdnWdRm0b4hBDM4mCBInOVqPOysYaQXQ5JXpnmKVSClPTCf0AIL0HB+dlmFA83DQM7cCG6QlXW9fm9i0ElmFSLBR584PfwZNPnGJycpp6fTvNM8pkyeUKI7gsjiOUUKOLaDhDaHc7WHoBU5poukkiNfpeQBi4mKZDu91GKUWr2yKbLYCSTE/PsCVrxJFCN3Q0w6LVdZmamKRer+H7/ohYUa/XRwLOYXT1kGGiD9hFuVwuZYOFAUQSNbjxh9ZBSZJQKVe4+eZbMZRGvdUgVjHa8DW9HralU6/X0+My+NnXYw2hnJ31Sshu58NguBsa/lshm+OGA4fptLsYpoVlm+h6ukPOZBxOnLiRiy+/wBtfc5IojIhcjwdvvZ2FI8eY3HcYL/RZXFljKXTZv38/pXKIbjp4XsoCazab2E4ujSExTPzAJVYaumGjG7CyvomS+mi+4LouYZjOjQQm6+vr9HoB29tV6o0a3W73ypgU7TJUFccx4hWzi+uxhmmrIzp9AprQ0XSDWCXpdUyS6kJMiyNHjjA7t4u+5+II8LppDEwUK1qtFmOVCpASO7QBXCmlIIpiNFMMrvcyjTih1WyRj3P8u5/9OT7wb3+Wd3//DzA9O8ev//YfUMqZ2I7DpUuXuPP11zKTTBd/KdNu4pVuDjuJNztJJ8NYhcvf53o9ZwLXgzhOKIwVU9sxL7Xu0UKXKEw71qnJWbZrTYSZw/V6LL18lnvvuR+ZSKam88SxgVIFDM2i328SBh5Tu/YThheZy02wVX2ZY8dfS/O8w+nlJY4Li8JECe2RU9x460m++MXfoZwUeOMbbmNlaQUpXSp92Jev8KXtRUIxgxQ6OoKM7VDMhiAserHg7EunaXSaRE6GwG9hZROCeC+zTgfNKxJodYRpkPQUru+jWSZtt5+GMiqBEBpeFCDihCAMydkZ1jsdssXCVR/FaxRiDHZrus7MzAye/yi+7+Pkc6MbvlarIYSgVCrR7XaJVfrg2KpuUet2yefzTE1O4bkxOjGFrI0XxehIgkTgDkRYQghiTeH5Ec1Gm5yTGazA6YPS0HWmp6YIB4K5sbExNjfXR1ZBruuOYLqh+HVsbAzDMAkHK3m/36fdS29cpQlkfLkzME0Tf+D+MD+1i9J4BT8MqVY36bTaqQffjvnY9exnF++g10qZetkNu5VhyXiwU0UgErDRqSUeBSHRXY8LTzyOKdNsqChJ0igCIbnhxAn+9D9+hInxcXq9JwiShHwEzsQ4973lnfzun3+Cf/gD30dze5Ozz51FFxbdsQjLdrBswdREGV0o6tU1vEKZTC4/mHFoNOtbGIZBqVTBNG2yToG1tQ0EySg+3vPaAyJLA0EadT3UR41oxcmAciwFqJS6Ouw8rsca0oWHD+ihfkroaRRFFARpQIPU0Aahk7qu88EPfYj3ve99NBvNtDtMFDIJAEW/1yNJBuGLSYxCESuFITXGx8ap1+v4roeGIlOyKZVL/OAP/QCPPf4oExMTvPdH/gl/+N/+GNvQabZcvvT4I7z7B/8B6A7ptOSbmfWm7D2IQciv+9qRh+LwS4N5nxQyxSNeAe1dbxXHEbm8SRSldO1ms3nZ6zNJmJqaQkUxa2tr3HjyFu669x6efvpp/CDk3IXzHD16E+VihShpYZkeeWeV8Yk8YwXB+uYF7nrNDO16m5uP3o5JjmfbL3PHkRKJtsRCZZaJxgLPfqbHu37iR9l++Tw9dRbzTRnWkw32XAwofqpOsg1trY00dMqFQroZ9AXlQoYXXngcLaNxdFrn2L7d+OEcwVqd55dfpq8i7rz1Zr70xKMo83LC77DLjuOEOIqI4wjX864gPTmOM0pYuJq65jtS0zRs20bTNO6///V86lOf4sQNN6OZBmESI7RU39J3fTLZAltbW9RrW9TqW5imQdzuoJsWhBFh6BADxayTRk3rqa4hGbxZfEm/00WomFgopudmEei4XQ8/DEgEhGFALpcbLEAmUTQYVAuJMMzUKkXTcTI22WyejFMkigP6fZdOo0McBbj9firKtVIrlpAEEoluGGhKEsQeSbePlJLxcoW52Xlq29t0Oh1MwwYVgLo+H24gMHbkAEkEDBzLo+gyOy5O1BVwXZQzMdsJie+y6q+T0yS2PjDDHAhN5xd28dzzz2DbNvVmqgzXVIxXmeUt/+CH+L9/9zd5+3e9g/p2lY2VRaamx3jq6a9RKo1x6223s2fvEXRN4XaaFMsZQiVHG5pWu0U2l6XWbJFxsuTzedrtNr7vYVvGCHpbWroEDOMuvBH2/kqdFFz25xvW9QrZDTsIpdQoUmKoSRlaBsFlXH9kT5OEfPj/+j/50Ac/xKlHn0CJgGCwOHueh2FcZpemkN7lDYlt2/S6PRzHZqoywdzcHIVCgcNHDjM0UfjQhz7EBz7wARQJm5s1Go0mlYmro/Re7exHcCWTbkj53gknX4+l6xpSUxBHNBqNEWQ6jLJBCOr1OkeOHOeee+6h3e1y5swZhJ6iL1957ItUSjZHjttorFPQFdLrcWR+CltKclJjYnYB3YrRHcXND2Tp1xJ0a4ZIaVTGJrjz2K0832jS2LrAsRuyXPjiRV5713GqKy7ll0zsUBGEIcVCnnw+fTZbxQl0U0clXR66zeO5hX0U4+OEmzMUcwYPvvtm8rttEi9icfVRup6BCPUR2zZFIobWRhrsIM1Aas3W3Ohc9XG8xrObXhBDQdzY2Bj3338/i4uLoxs/jXooE0UR586do9Fo4Pup43c2m01zQYIANw7ZbjU4e/ECzU4fPwI0iySW6JpN4Cfoms3szAIT47O4rkuz2RwNydK8Io98vjDCL4dU9ImJCfKF/OjGdRxnByQliGOffr+F56UU8VHqq2kSx/EobM6x7VHy7YiFFkf4vTaOpbNn9y5mZidwMga2ff2y7EScQBgjY4WMFboSqCBCS0BL0u5o5+4zl8sR+33KtoWnRUQqZc/4vj+CvRzHYWVlGU0TJElEELgoFaOVJ3nd930Pn/zMJ3n96+5G1+CFZ5+BOCQIXI4dO4xuJCwtX2BxcYkgBs1yRthzsVhMtUf5AkgDL0xGXoS6rlMulwmCkI2NDTY2NsjmbLq9Fr1ej83NTTzPHXm8DRelV84ekoHn2PVawx5g6B0Jl1low/c0RCqGr0m7+tQD8Gd+5qdY2LeXQqU8mosOP4YPi51REc1miyRJyBcKTE5M8NCbv5Nf/N//Pbt27UIKHSF0hJDccsstKUnBNkHpdNptBoqOb/5+Bh1f8ooh0jdj0329bkiK69miS1Db7hCF6bNiOEIol8tIKdlYXx8ElUZ87GMf4+Mf/3h6LpB4vs9jTzyC77WYHtc5smeCyckihbzD6soa0uhTGnNAhMRaBscpUy7lyI8XsfOTbLcU/ttLfC37OeovfYE778ihiSarlsCqzKI7EZuvr7L7piyNfhPTNFlZXsY0Tc4/d4pTTz3BuZVl1tdtnPFDxPUsx5mmaG8xdbPJ3JTi6GGDf/W+H0jvfdtJgxVHzNpUHB2GYer6n6Q+lsNztVMa9LfVNS1IQ1huePFbls709ARz8xPEUUixME694bK+sU3PdclkM5imSaFQwNAt+j0flEav51MsFhkbHyeTzdL3PVw/wg9BM3IoYaMZOSzLIYoSstkcxVwJSzfpd1upNcrg5mx32gPoxgMEQRARhjGO5ZB3MhSzOWzdQJM6SsX0+k06nQ61Wo1er4dpmqOPKIlpdzvYmQwtt08QByQqZepZlpXaJqUOYoDC73UJ+l2KxRyzc1PXcii/pRWhiMTlcK0YlQpYUSgpUkYJ6QXm6DqOaVApjlHv9RGxIFaKJNHxkgikwEgTexCJRMfE9WIiFWKXJrn5jffxyKNfZn7vHFGccPqZpwndLpqmY+gamoTjR48gSXjy1BP03B4dL0GzbOI4pNvt0ev3cL0e3WYdr9dGaILNrU28fot+p41jWaPuoVlvEAUhzfY65XIJP0hQQiJ1Y6SMRyrEYIM+7AA1IUcms9dfKeIBw04AlmlimBJNB22QubPT9duQAl1AkohUDiEk/8eHf4nZ3bso5EtohpVqkQR817u+h70H9lHOF7j13nv48K//OokKcJwM2Uyerufj5Ispm2+nfkSkNkB+u0uv36bb7fLCs6dJxPC3/CbvRu1ICdhROxmdI2mC4rIb/SsqTuJvCg1+OyuKEzAMOl4qHTF1g8AOyek2YRSw+/AMMTYTuw6Bobj/jrsJY0UU+wS9hKwGx26cYHMp5OylVZ57dhnH8CjM7mNmzx7C0CcyIqbm92NlS0g9QzZvURkrsXdmN91Sj4iIux5wGC92CLdbvO6ek9i6xcxDh5h4YwV9rEZz9UU2Lp5lda3K1qUXef6ph/nK45/n9Q+9lxtf9zNE0QLT2112V7eYvbvCHDHVWohhOWTyAmGm8/jAC9IQwiCF6gij9POwRwREUUAkBk3CNZyza/ayG7In0siICMfJcezYMf70439OqdKgVK6gD6Jus9kcUvRHu53p6WnCMKTVarG6ukqxWKRWq6GpVOhnmia5fD4V/AFhlCCkTtf1kYaFZZjgB4RuiNvr0uy28dxg5OE1tPfpdrujneWQaaVp6VttNlOzVsMwmJqaGnV8SZKwurlB5Ic0mw263e5g99hESn1EWtAH30dKCXGUxkYLrolJcr2WlBInl0HFMbVa8wqIK45jNCTSkOgi7U4zjoPreaBJctkx5o4f5uzZs+RKRSqVCo898lVmZmaY2TWZ0silIPD6EBeYmhwnqda4dOEcheIYfS+Hbdv4Xp+NjSV830XXLcrFEoHfp1jIjnb73W6XcrnM2toa3U4rPe/5MuVySLlSptlsDKAsfdQ9D9/fkOwQBeF1C/8MITshBGLk/8bIxHcn+26op5JSIged/rCL+tVf/VXe+4/fS+dcFzEwmf3cw5/hEw//OU6pgKMbaEJj7569tJpdVKKQUuOZZ07x0Du/+1VyRinSCAtzsDn7xKf+nLd89zv523ukFLILo7/bnPWVsRbXY+18NiZhSBRJZJiwFG3iWBbr59aYHJ/lqa9+mkP7Z7i0eo5Wa4s4NBBal3/9Ez/Onz38NC9+7S/5vd/7OeqbK5xe3cf99/59Tj13Ci3ZYu/h/eimJAkSLDuDkAPnfV1Q1GIWWMW+dJZg7gZkeZq4t42wLRwdLr74HPfdc5QbT9zA6SernF1qMlFeYGpjjkxJcP6p38UPJyj4IcVuG5GRiJkQpRvMz5bZXN+k3XLotmLGpy16/S65XBYGDiA7mc1xHOMPpD7AIAmidVXH8ZrO8M6HEwNao2U55LJZHnzwQVZWlkdfd/t9ms3U7qdSSdNaXc9FSIHj2GxubrKxsUGlUhl1LMvLyyxysQRXAAAgAElEQVSvrdLqdkkAP1b0g5gYHT9RbDfa1Bottra2WF1bwxtw3oc+eoVCgenpaWZmZigWi2QzGewB3TyTyaDrOsVikbm5Oebm5piammJqaorxiQlcz6PXatNrtWnWGkRhSLvd4tSpp/E9L30gS3kZ3x7AEFLTMHXjut25fbPaSfsewiqRGMRpDJT47HiNrukjcaxpmnS6XRKRRmwfu/sezGKOiYkJDh44gCYl87NTTFSKaeR9GCJViG1o+P0OplTsnpthfXWJpQvnWL34MpdefoELLz9P5HfJOZKJsTxj5SzzM1NMlIujSPp6vc7Kygp79+5N4cU4xjAczpx5Hk0To0HyK3fkQwrrEK67Xq2DhmaiOyFHQ7cQ6CNiwpVohTl63XDeZBgGlmXxUx/4OTKWjalpGEIS+j5vfeBBNi8sIhVoQvCTP/lvUn1WkuAHPqdOnWJ5eflVx0cB73rXu3Bdl3a7jdsP+fxn/vJVYtdX1mX47W+3a3ol81MKOYLqlBrEN1ynNbyuYlunn0mfCJXxElqicfsNt7BVXWHfriIFS+exU08SJxGazGBY8OmHH+aTn/wL/sOH30/gCcbG3kZ55juInIREk+w7fhCZESihg2ZgWA6GlUNqNoaVRTcM3MVFeo8+Tu2FFyGOyFqSVm0dwj579ixQKucoVSwmp/MszGmM7yoxPjXDXa+Z556TWXLjfZLFLRgPMA1B0glQUkdEHraZwe0rsk6Z7XqbrtsjVAnoqV+dpmmDJGadOE5hfW8grbiWzfo1LUie54/mOFEUIDWBpgkydo6ZqXHe+c7v5KUXXyCJYqSQqESxsbGRzphURBT5hKFHu9PE8zy2t7dZWlri/PmXWVy8yOLiRc6fP8+ZM2c4e/YsL7z4Aptbm5y/dJ6LFxfJ5fJMjk0yNb+L/YcPcvT4MU6ePMkNN9zA7Gw6Z6rX60gpsczUfDVKYnLFAlNTUywsLHDo0CEOHjzI3r17GR8fJ/IDnnzyCV48d5ZGvU6z02ZqfpZsxkYKWF5a5HN/9VkCzyWOUvsVpdLwlkhBigVJSoXytRzKb2EpEqWuwO8TTYChXWHlr+s6TjaDdEPq3fYVEEoyCImLVILUNEKhcPt9lC4xCznu+e7vJNAVW1ubZApZdF3y4vPP4vsu2azD2NgEtmNgZAo4WYdCMUev06Rb3yDu9qhVV9BiFz1pM1ay2Ld7F7umpymXS5imTZIEeFGIbWm0WzVy2XSQ3u/32bvvALaTJY4hmymPNifDB3IaVKahlCAIvNQsktS1Y2Ly+jxnYeATGwlSCoSm0Ix01B8TY5gpc9QwjBG5aAjhGVLDkGmE9pDoMDc3TkKIbmgISQpjJop3v+t7uf/e17F88RK79x9ACEVpkFvT8yM++NMfoNdqXr4OEAgpeMe734Xf8djeWGerWuWjv/27bG5uXrG5+XqlVJoUi3j1a145Lxp2QinrkzTeRF35teuthhsCgNuSCSpOzMf+0y9gxS2md5U5dfY0kxMl7EqFLzx1HqXpSGw0s0XsO7x09hyPfPbDzC8k/Np/eRz7yO1Q/QiPfekrqLCNhYYeOSRCA81ASR3DymHYeTRhIA0Hc3KO/lZM6bkv0Xn80/R9jWyhgBeGBHqGjj/LpcU9PHOxxf59OQ7tg/vufQNb200uLfXZ2DS5b2M3faeB1u8hP64I+h6ODrlCwvz+AsWCxHRyXFxe5vziRTTDIIriK5K5hRDYg03o0Pnmqo/jtRx0pRK2qlXcHQ7QmqZh6A6GblIuF7jv3nvY3NzANE3y+fyO0C5Bp9NhbW0dKSXlcnmU6Lp7YYHdu3dz6y23cOOJExw7epRKpULGcVi8dIlnnz1No7rF0qVF6p0WXbePH0XESuH56cK2sbEx6lKazSb1Wp0gCKhUKizMz1Mql0eC2Eazydr6Oi+ceYFHH3uM8+fP02g0aHc6dLsdVldWsR0Hc2D132g2qG5V8f0Ax7KxdQPHtAaBVxmKxRIXL168lkP5balEph9frzRTp1VvvHpoLC6r5xOhiJKYfuAhdA29mOWGe+5gpZZ6CJZKJXRdZ3V1ddSxDgfuuq7TaDbodNoIUipzvV4nm7M5efIGdu2aZXx8nMnJydSp2DSxDQ1Tl0gSkiggn8+jaRrZbJbDhw9jGAa1Wo1sNotpGNiOxTDlttfrjZh4w2EyMCK93HLLSXK5zH/fA/53LLffp1NvMswUGgbbiUGHsVOwODS9HRIdUocDLkse4oR/+WP/Ciefw3RsNP1ywmun0+Ed73gHP/7jP873fd/3jRANgHavy+OPPnrF76WU4vTp06kFl64T+KmR5wd/4ReuqtsUAuLo2jucYacoxfW5GAGoOEbTTB689zYOWQU+/qsfYe6OKV77mpM0t+Hu22YpOjm++uSzqERDUwmaEaauNkrwm7/9QRqtGnGS8KYH/h4lzWN2n8vJI4eZnB4nRCfUQFMJBqCrQcgZIERCRI6ZsSwzjkEupzNZ2+L8w39ARrdInAJJ14Wox8LBIxTKNvvmj7FeKxPZ01RmjpErz5IzbXrHbTqripf1DW5vTbO2DGFgYDo95nM6P/v+HyGTMWi2Y544fRasDEEi0DMafhJg61aKWiUxEYJExRjXMBi6tjMsBJubVVq1Bt4AxoLU280wLHJWkT1zM0xUCiwvL1Jv1FPX7TAkiRVjlUkK+RKV8gSGmSGJwdZ1FubmueXEcY7u282hhV3MTU6QdRx0Ae1GnWI2S5zE1Ot1Qs/D73kQKWI/otfp43sBgnQ+0Gl3aNTr9Nw+0kwTEm3LIkwUi6trvHD2ZS4sXeKxJ7/Gk8+c4vzqEtVGnVq9TsvtEZMqkKvV6sAKSaPttXEDl3y+QKJSkkAiBdMzu3C9gAsXFwnC6xVKuAz7KJF6U8HlQfMQqvOjiIxl0+12d/jaXRbPCiFQUhCqhEglREIxt3cP/cAnCsORge1wARiSQAzDIJdLadue66HrBn6QUvVnZmYYHythmhLP83Ach3w+j2VZZBwHUxNIFaOrGMdMh/j5fJ5arUar1aLf719mfWoagR+yvV2j2WyOIK3U2ioYKc+VUnS6HapbG9z52tu+jeflG1cSxzSrWwRhSOqToSMHImQ5IDUMz1swYDOlHUq6SA0jVKSUaAm8/aGH+KM/+WPe+b3vYnJqamSNNexqHn/8cfq9PkmSpHli+TxC1/jCZz/3KrX+nXfeiWmlFPR2p0Oz2eRqZkhCgK4bV7VwfT32HaSprNcrNC6lho7HD//wO/gnv/kPyU66lLI6b3vH67jzDhs7yvPSYhWERqzZoOVIIotIZbnx1jGO7B+n2ujQ6h3lta9/CD8ep9N9M7nxSXbv3j1IPxAg9dR+C4EuQZcJsYhRxBTGMmizDs9fFNC9BTM+wlf+8m/wNttsdRx81+Jrp77M8ePzrDQsTpx8BxMFydFDh7D1SZJ9guANAXt/+O34r53mczPnmC5bhLUAtidBucyMd/hHf/9NjFfGkJokjELOvPgSupE+YzVdJwxCbNum03cJYshk81d/HK/loAshMTN5Xjp/KRW9DrybgBFskMna3HTTDQRhn3whSy6Xw3GcUd5HedCpBEGAaaYq/SF+res6plRoxMyMlSmVSkgpqVQqzM9McXDvPKGbpsMuLi5y4cIFNra3CJIEYRqYWYdEE0QCIpFCTf3AZ3Vzg3a7zcbGBltbVc6dO8fGxkZKUxzQYIfvZbjQuq5Lq9UijmP27NnDrl1zqCRljRSLqdHqxQsX6fV6VyzO12vtnEeMqNAC0CVKE3j9Loau4cuUgaekGJlEarFBqBKMWKELQUZIchNjzB/cj6br5DPpgjM5MYGlCeIwxHayI3glzdDKUczmadR7hDEIHeycTr/Xpr6+TRB0SaSOkjZK6oTExArCKADdQmgGbr8LicC20xjzbL5EHAX0um3K4+MUi3niOKDf72IY2siPz7ZNHMdifKLMHa+5hQceeBMnbriNSxe3vp2n5BtWFIX0+y66BEMXJLFPYmgITUNJBSYoQ40iwofkBk2TGIaGEAqRxEiVRsvrlkl5fIx/8WM/xv/zx3/I1MIMpWIOHQ1D6EyWd7Frz15k3qLbbadWWGipJiyOEUKN3Lc1TcPOODhOHs3QyeayLOxeAHh1d/2KksJE8bcb2u5cLHdGnADXrdt3rBJ++9d+gbGSzl998RnOvnwBN4hY2HOQH/zh7+LJ0y+hG5K9C2MI6SLwsQixRcJvfeSXWVutY4oy5xd9uv0I3Qw4cPxepOkNqPbpJiJRggRJIg1CVxH7CRLQowRZqJB/8/dTevOPsDL7Wp5LpnB238Z610SYRzn91y/TfelFeisxq1saX37sE0yPNZie9Dh2fJy4ZbFZuwWj2KZws2Liu3KU7ATRL9HdSmgHPraZMDMzzvbWNr4fUKvV2bNvP+cuLRHGkM1k0+MRR1S3Gywur9Jx/ztZBwHouomTL3D+wiVymQxmxkZpaQax1MA2TAr5PA+88Q089fQzGHoOUNTqNYSUzM7OIqUkX8jSbDYJFeTyGZQK8fyYJI6xrQy2tJgol4hDHydjkc0VmJqeZnaXRqNTp9Fo0moO7PbdXrowhAGe3yeOXfK5LIQe6xcXyedLUMzTaaSLX6FQGFkHlWo1Ll68OIq2GC5OfuDiBxGWleXOW+6jlJ8gm8+TyWRYX18fsfeUUiP89H+k2sni8nyfvJ3BH/j+DUvI9OuJiEmkoLyQshJlAuN75lnfrhIFAeVyGd/rpqFeJClleZBEG8cxnU6XQtGhXC5TrVZZX9tAiElMS2DoBt1uGyebw++GaMJDKC1N5ZV6GokeJ/hhgpTgun1836VT79PtuPR7LSqVCnbOZnJikrm5+fR3F2K0URh62zXrfR5/9FQKdYnr14ZGM3WeeepRbjhxG3EsMHQHIQGVIIVAxWmUhyb1EalhuPgO4budfnBSDGLmhSBrO/zBf/2vvPcfv4dto0rg+/R7TR7+s0/xT9/7T/mN//hrA1i7Tti3efb0aW685aYrzGhP3HyC5559Dqefxl4cP378qt/btfJIvlFW0vVWmazFTcf38vLZM5R7ZY4enmSrd4ZW4xCBWeFffuDH+bUP/2d++Zf/NV/4ylk+8iu/wR/+zm/w1Ucf5bvf/F6MvMmeXIGf+KV/xyNf+mve/rYHeOzZr3Hz8Zs59dyXuPfuG1LCERIpdBJi3DZkcxpSBmTQCAtzdDXJ+EmTwm0ZWNeYMgxWV5apdc/h9C5wdBoeu/gsa9zNHSfvJmi9SD6boVg06McKmVtmfVHjxoM5tCChX81TqhwgtJ5hPdFxt8D1TV5712v4/Je/SBxHfPmRR7n9NSf5yqOPceeJI8RxTKFQxFchhpb6eFxtXbN1EKSq7iRKPeM0UcZw5GiXFhMPnGDH2b13gfLEFL4bU61uk3FSg8d2u41j56CYMjPOvXyRfbvnMfI5TDPNoB86QkxMTNDpdjmw58DIkmN7e5t8vgAqpWMP4Z7NlUW6nTbZjEHBMshmC8RliMKEsy+/wLPPPjtweJBks1k0TZLN5ZmamhqJe4ezhiEEcuTwYcbGxpiamqLf77O0tDRy5B0KLn3f/x/iphnWzjyaISPNUjLVGXHlgFYBiRaza/c8Zt6k1W6TcXJoljGCjYZ6Ltu2iX0v3VEnCfl8nkKhMPh56ffNZrM0mw2iOKRSKVB0smRziq2NVerNBvPzexCJhRAJmpV+736ng5XN02o3SGJBv9cjcD0yloNjj1EqlXj6+ecADc/1SVRMu92m1+tdcT5hCFFKpCbI5jI0m1dHR/1WlmVZbC8vsba2yPjEOFJKbMcAIdClThCEeKpHNlcEroz3HtJudzppS02iIxEKdCHRLZvf+p2P8u8/+POsrKywubLK3MwUD77pAX7lP/wyUpp4fhev0+cXf/EX+ejv/x6aftnd+3/76X/Dz//8z1MolHjjG9/I8WPXsiBd/SZg56J6vVfgKSLVZL0nmL7rdoTZoxRlcMe2WD6d4H9tm39091sglBydmuCvPv2b+PUer7vpLl7/xnfz1JlPsX/3XvZOC/LlCRJdUq4EROEl7rr9MHGikQgfU/koFWPqisSOQddQnQ5m0icKPOzZgyQxNLY2qD/1ONZNhxFhg6ydY1lqrMpLzBdDqt0uU/NjFLUyQiiy+YjXv+Yw5y9tU5YOW/WQqYkYe09Aq/skrtIRLcHFzhi1muTowZt4/omnycyPsXZhma8+/hQ33XwLjz35GDceP4IlBZrvkRsvMp0v8MJVHsdri58Q6QUVxwpNszh/YRHHtsnp5miYrBkGhhQ4ScLC3C4+//m/5uSNd3Bo/35a3Q5LS0upODN0KZUKGKZLvbpBMZ/DsS0STaeUz2FIHb/dotvtMr+wgGkahFFAs9Ug8EPWOxvkcnnW1xu02y267RZ9r0mlUkIzDUxLh8RH102efOoJnjl7jjAI0mTXwYN4bKxCv99Psz1Mk9Dz8SIfwzS45843UCxWuOXmW5iYmOTs2bMDYSwYpkEQhZi6MXrfUXj1auRvbanB7haUuAyHpKr4NERM03U0XUMaFobnpztq7TJkks1lSUTqcedoJro0yOcKdNodxsbH2N7eZnJqEtu02Gq3U3+1KKDT6TA2NgYoet0e5UIB1WsTRiFJbFPdqjJ5+BhxLHAcHz9os7Z6iZldu7AchzByUUrg9vsEYUTku5h2lsDziMMA0zAxbZtut0cSRhw5dpBnnnua7doKhmlyw6HD1LfrOE4e3ZS43TqOnUcg8P025VKW5aX1b/cJelVFUUzOLtGsbzEzN5XeL5FCqZhIDLQuKqHf79J3BSQK0zQYLrhSS9N+kyRGkxq+20fpJrqmAalNlKZLfvpnfjqlx7sulpNFCA3LtkiICYIQFQnanR5/+fBneevb38IwnkTTNH72Z39ukHeW+kpebaVxJwql0mvyWiq1MLo+N35JkvDyCyYzlT20eptk7IMkoU1JSfrNl/iOdz+IKjTxdZ/piSNkHAvfb3Pm4jI/+Ka3U3dPs3v3HK2ex1Z9ifr2ee659zimBqgGQhUQMSTSJj0SGma+gBZKGpeqKDMhLBlYsUnkwROPfRWv8wSF5r0sLv4WM4d+iAvLKxiBxx17buDiRo/6y89SOhJhWTpRHLN7QrJ6vonfg+xEgY7fImPGuFLQjVOodbPaoxuVsOwM3bzOxrkLTFbGieOYU6dOcfjoCZ6/cIlKpYIb+MStJmoQTXE1dU0LUornpvHWiRIUSxWWlpbZvS8Nuxvu0DRNwzJNCrkCJ268kfWNVZCCMI45dvQwYRiytVkDEeN5bWzHBinwfJ9E12h1upTzBYQmmZ6eZnZmhjBKB9PZbIYgijHNQZQCMY5joSIT2ylh6Aa25RCEMYurS5y9cIHNrTphpIgV+ANvMDeOqW5tjyxYbNum026RIJiYmedtb/3ukV380tISmqaRz+fZrtfS7JMowtSNkQ4qk7l6auO3ttIxsGBgMKoSYhgtSMNhvyYTHAE9fRBXrhRiMJeYGB9DSI0gjEBI4hjcII08TpLU8Lbv9gldD9MwSQYPRMMw0kWpUkEpQd/zyOQcJsU4W9UqExMV4kRhZ7IYusSOIlQEbrtNEibohobvedhOJk2K1SW9ThchBdlsDmFoaLpke7uJITWiJEAlGaamFshkCximRWXcolZtYSQmpj6DaZjUGltYVo7qVuPbe2q+QRmGgW46TE3NkXGKO6yBTMLIQ6l48HlqiaUJSRAGaPKyIWscR/hBF5REAkHg4Q+ZWUIhfEEUhQiZum5EboQUGpOTEywurqCQSFOihM5//u3f5c1veROanjLwJBoIMLS/m7dckkQIYfz/eMS+/VUomDz21Kc58/zzTBqzfOk//TGu2eZS2CEyBH/wJ7+GpnI06zVUlKChkKZGIbPAn/zRnxLKBmNjGbBK+KFkV2mKv/mTz2DYWTrNOvt3H0ElPpP7HDTpYFt5SuM2bquJOtcjVymzFFax7GfQshaf/8tPMFXIsNpYp9sUfPzTD+NWq/hbMZ/4i4+h79nHo0tnmP5Mln6/Q99t0026LC23aDUEhurQ8TwSIPIV3SBAjxIcVaLZCcgQ06oklNDY3N5iemISIQTV7TqmnWFlbQNTl/R9j/H81ZMarjF+Ik38TGcDApUkTE5OUq1WR3TcnQwgy7KYmpqmXmsTBT62adBtbANQKudotxt0ey1yRo6lxUU2VlcYm55i9655mnFCNptlbm6OKIpYWVmh2+2m/lBjEyNCQur63KOUn6Tn9keK4QsXLrDVbFNr9en5EVEUj4gTw51/GIZ4A6sPKSWGYzC/+yD/7J//JKrfYXFxceSRZxgG1WqVMAqpjI0RxzFhEFAqlQZxG9drHhLoiFSFr6W706H7906BaBzHZJTOhDQRSqALLRVoSom+2UEgMJQGlk5vLBVehrqB67okSUKv16PoZEkShWEboy50aADa6XQQQlEZK2I7BoVCnn4/xPd9dAOkZpLN5DHimL4fkCQB/U7qKei6Lpqm4br9VASopZBUGgGSssKazRrNRo8TJ27ixbNPEngKFQdYFoyXc7R7AbHSWF/fIJu3EbqDf53Gzg8dQoYRFMOKoghDt/B8L/WGiwEUiQ7SsDAHLiIqSePHg8AnXyiN3EUYxUm/ostQKVkgjmOOHz/G9lYD33UH878OmtR57vnnOHHi5GABuuwUAa/sWiKGrc8QnpNColS6LdI0SRB6WKYc/R5KpTD91UBz1yt8V8gXePNDd3Dbja9h7+z95PtV+oWL+EGb6QkbFQQUpmZZXH6Zr3zlb/j+Gx/CnchQ2jvG8rOLmE6WpaWX6IsCn/rYH/P33jrD8voSARrFg3ka1U+TzXrUzuuUCtO4oU6yfYCnz3yRA/kFKB/iwKHdaGEXfXySW0+8AWulzd65L1M1DPLFOyhP3Uxn+YtE4zO86a2vpVzKI+IIqQn6bhtTJbR6HZa3XGbn9tL1PTpeG78ZYdtZ/FqPo48tsL14jq8uPsMvdR6hgEGUtajVaqkTj+fSqdcZK5fSYNUkwslevbzi2mZIAmIFtu1gmxbNZpNqs4dpCVbXVtk9P4tu2BiGyTAiYqxY5IajB3nx7EvolXE0w6bXc4kamwR+m2mngLANYiMduI4V8sSRy0Zzi86FPpZl0Wg0qde2sJ0sViZPu91N5xWxAmmh64p9exdwstaADQSPPPo4Z86+TM/1iFSCilMNSjyIqxBSopIEkShMJ8e+w0f44R/6n5BScvHCWSwj9bfrdDojx2XLstIY8zANAXS7XWLdIIkEpnN9aloEqRZRk+kCkySKhOSKOUOSJFwKe4zrOnlTQ4bJQAiZ7q4NZKpHkoI4MIn6gvGB55ympyLNOAxpRG0syyZrFtAHGq4oiqhWq4yNjRG4qTde1spjjessLy+yVWvgRw65TI5YxbgKDNNE6KCL9HvEYUiYJCA13J6H12uRRAlm1uTixSUajRaViTwbGx3On3+awNNp9TfYNVEg0mO8do18oUB9u0sierieg1QexjXs3L6VFYYBGcdC6nKk9btsrioxdPMKP7tRhtXgGlcCBDFCaGjSQvxt+h2RXidSh/37D/KJT/wZSQhC6AhN49Y7bmXP3kNo2tfvaq5cJPQd/67t+PuA0KB0pEylAXGSkoJUkkKJKQITIKTYYdpqXP4ZUvydOrJvRW1vtXjoe36K7735fhYWXmLf7j5hJSGOXD7y13/D2x64l32Hj3LoxhvoVpucXmtz7MZ9RJpFZn6OvCMwMgvokwexEp/jtx3hiHQYmztC4nm47ibZTJFLZx9nsjDG8ssXyJkGN936QxREhdjc5mO/9V8o7jHJyP3sOvogcfQnfOnhxzlw+5uYMNvsXrqE0094SVZZeeIzLOsxk/v2s3/3PE5lnIKTYcGUHAgDnjt9nr/+9F+QRDZ3vuG1WKLNC3+2zHl6PPHEZ/HsJj/6z9/P3zz9CEtffJgH7ryV5547R9P1sLIZ3CBA1zRMaXBhce2qj+M1RpinEeBJktBut0c3ghQartemtt1kbGICTUtGTJ+hA/ju3bv52pNPc8Pxm8hkMgR4aIbJpXNLFLM2Oduh3+gQ0mF6ahe6bhLFDWprVYIwIAh6CA3ijiJrFwnDkFwuh9/vkyTQdWNMW9JsNvj93/996vUGQmlITSCSCBWnDKQhTDWEQZJchje87n4efNNbqG6ujZTvxsCPL5NJF5rhTt/z+uiGRq3eRjcter6Hlct8Q8Hp9VI7tSRDceQVO1sBvorJo2HoBlJcvvl10oXLEBAKjUSm+hfDNIkHMK3v+ylu7Pq0Wi0mJiZ2XB+pCLOQcVhbXWNychzHMZiamaHR6KLpYBk2vp+e0zT++bJ2SJcammmmsK8O/V4Nw9SJQoNut46Ugig0WFnepNPpMLtrP/5qn0azidTD1MzX8snlC2ihIEoU5UqJ1ZXrU8ycxAnlySmmpmdGXchw7jckaexcpIyBIFYxnA8O0j1N45of4G9969v46Ed/h3ajRy6f453f+04eeOABMlettv9mHUzqLxgnaSSM1AbvC33H/7NG3Vpq12WNSDbR0M7quiyBaRW5960PsX9PRGleI3AkRuBx8+2vxVABIpFcqJXYMt9Mr3yW5jNP8/zpC/zP73kPOB5f/uwXue8tR6l1+vRDEy8MKfgeUjMJfR037JIwg59YbDQ8KrkIww6JprJkMjluPPkgB16zQJIrEnplLnXnePvtewiimNrqRU6/dJqx4jQnvvetVDSbpJTFtWwqvo0fSDRHxzUdyIQcOZkjW6nQ7yoamx6PfuWTPEeH17zlXvbMHqRybp3zf/YZpO9hx4JzL51n1+QYNNv0B921GUMswePqJTHXOEOK6bRSmEMINbgpYpTSsZwsi+vrGJZFsVgcqbmlTGG+Yr7ALTee4IXnX2BhYS+mYaKpLEcOH2BxcZFGv3simdgAAB10SURBVJfGK2/7WKZBojJEvkujVqXdagMBjdoWlpNlI4SZuXkSFSE1i/HZOUzH4ZmnnuaRRx+h3mzgxRGZQp4MeXq9Hp1Biqiu6+mNrJncdPIWvuf7v5/Wdo1nn36SsfFx6u0amUwG3/cQQkeTJkolJEmE63ZBCDLZMrph0+/1yNhOKtA0r18d0s7oArgc2LeTgSaFwCceODKkkJ0YsLSUuGwfE2lp3p1hpHCdNXDebjQaKf3attONgu9j2Tae5yEHOgrP8yiXy8RJCjHpQqFUm82NOlLpGGZKcbYsnSAMSFR6vjzfxzFzJAPLn6npWbbrbZrNPr1eL4VNGx3WN9ZIEsW5i89imKneTeoCp2himSL10pNZVjaWiMI65XyRpW/bWfnGpRLFgRMnkJp5hdfgsBsa0rtfFbK4Y/FRXA72u5YyDIOPfvSj/C/v+2fce++9vO71d5PNWejG/3dIeqe7N6S6pMufD99n6g2tawa6dmWy8Qh6vA4rV8jT6jZYam8xFmYRvkHeKhN7NtkcJNRwXZ2w6eDWLnLTyRKWUeC2vTNY/jb9Xo/XfcddiMSl1w2ZnztArbaJhUdf+GRzFivnnqFSmCHsr3PHLbP0FChp0+lskd0qsXD+ICubS6j7LrDy9DlO3H8XytDJSkF+PmH+9vtx/Qi9oAisLP9ve2ceY9d5nvff9539nLvOyuEMhztFURK1WqZkyUttJZa81Fa8pU0bI0sDBCjQoimCAg0c9A8XroukDdLUaeu6NuC6Dup4i1U7cB0vkiXLFLWRokgOh+RwOJz1bucuZ//6x7lzSSlyTKq2NEHuw384GMycM+e753vf732f93lkoKjWUjaOzjOyfQoxJhBIzNDHcEymp8dZXW6xdMnnpvvewt2VMmdOnef9H7qHLFC0H11g9w13cfz3z+JUtrPh17Ask1o9FzfWbTevSF1HmfW6ad955mX2G5MvPUKPj4+zsLDA7t27KZVKg3ID5FTxUqnEjh07cBybONOJ4hjHcbjh5sM0m01Upig4LoZV4kfHnuTCubN0Ot3BB7hcLFCueNTaNXrdHl6xTJqFCBXyxA+e4Dvf+w69MCAV+ctZ0nUsy8x9mNJ0oOBdro7z67/5W5QqI1ycmwcpcCslhBC5okAQ5A6QhVJ+/zIhCjOE0NENc1CKskxrcJoKg63rGHt1SSXf1MRfl/hXuUVFosASfZsDkftNJ312VUiGrBSQmo5SoGl5GdP3fSYmJmk0mnhePgitG8YgEHqeR7PRYKSYM9yk1EgTlVsjKMX6ao3FCxfZNj2FaUbU683cw0rmCZAh8/EAoetICX43ZmWtwfyFs1QrYxSKBTLVo1xxWVk9B7qiUp3BlBpr64sUCg4WAqFp+K0uIyMFun6HjfXl13glrg2mZTGzcxeGecWZczOheHkA2nRR1rTN91AAqm9U+eqO7aVSic9+7rMkSUzQ61Lojzj8rKBpOooMcQ339/LrbtXz0eraKoaj8bVvf4OZ6Q9iVzJsleJvpOzZXyEUCd14lKJqssP9Ic8/Psq+ex7g6DNf4MYb72D3TbcThIsc/cEP6DUC1mOXwvab8KM6rixwaWmOyW03kmmK5089weFb91F2t7M0t4KRQOfoIjO1W6Br0xZdDo6MwIaOM5KQyZRS5hIrxYhjYkhYS2NKKxHRmVVm1ChBJ8bQqsSRiWgkxHYPXSRUS5Lt+2Z47KknucVMKZunWFydRhbGKcuQg+2dlM0qD//yR/nkv/0YSeSjmRKFRiPsMeqVsIVGnWvr114nqUEgdY04TTA0nTAM+8EpBhRJDKVSldr6BpYucW0bzfRQSqDrBq7rMjk5xvETJ5jeOUuiNDS3iuNomIUKrVYLr1hhbW2d6R07Wa812GjmmmTdXoeNVovT5y+QZhmFi5fodntYhk6a5R7u3SQhzlTuMklGvV5nbGwsl1PRJC1pcOMdb+S3PvpRLi0uocKQYqlIBhi6TqvR6LOXdHrKIxGCoNNAiLxJnPegIsIgQwpJFOWCk4ZpILdo8qZ4aZYp+vTtTbvyTUgUKhNEQqMAJEqhVIamQGr5hhgrRaJyySYhJIVCoc+0y6hUKtTrdaojI7n0PDAzM5OfkKTMbUU0iSYFrm2BAl2YjI6NQxojkogoCllZXkapjCDo5maKYY9iqYCleTQaPr24Sb3ZYm1tjcmxbUg9V+NoNTtsrDewHYmSNp2ujztWxnLL7JjdzfLKIlK3KJZLhGEdvWiRqZDF86/HqvzNsGyHyckJTP1Kwne12dmmeOyAwo9EIPtU6iunEMOwr/vamz+vKYlu2Niv4nf89GtoKJXkch389aDzStj8DCdbNSQJRZbA0aeO8fgth1DaTloVDUtEuNVRdFGlndY4/qOjVFaXML1R2s0JzNJObti/j0A3iRuKO28/xP/8r/+Ofyx/FdFxidpruNs85o59hXse+l1++M1Pc/eRA2SmSy8O8TyHxcfPcvP8bbRlnUJqc/KrJ3iDP40smtSSJZp3RJTvDHGKCZEmUL3djCjoPTePkCZKxJz67mPc+I73kBg94rJO2EjznqGKqWhNvMTEDwJGKoLy1M3MX5ji5LljPPbcn7Ln4K14zgz//Hc+zqf+6OOMTDqcv7iBa2b4bR+7MnLNj/E6t9ErEh6bJYOc6p1nPVJKhJS0W03qDR85ooMRo0kDNA3TNPEKHvv37+OZ48e54/a7+wybvAlbLo0CGeMT41SqFYQQA8kfKfP6eRCGIASra2tomkazGV6RqOk7meazRflUe61Wy0tIqeKNb7iHN7/1AVZXVknThHqjQ6FQwOw3hz13BK1v+ayHNeprdSYmJ4gzvc/00lFKoMl+D0Z2yZSDSg22T+25vkf5muHKC7wp/bKpUDCQYxlo10GcJWSGMXjxFSD6/aZAA1PX0PuDy71ej3K5NNCKGx0dZWVlhYmJCSYnJwenad/3cyqz64CUSF3Hse1c885zGZ/cTqFYodNuEYRhruEmMgzTxBAaQdAjqtVIwph608ewvYETZ5wkqEwghEYcd2k1u1RHywRBwtLyOp5ns7iygWF5JEkHzy2R4hG3fZJka25uhmHiOM6V0tbLlReu+r9SCqm90gCp+P8SI/15stkE/fm3a7i9q3tG6grTYevhqo/SV//sa7x4cj9vuvtuymM67sQEuqk48+IlxrYf5rlzPnNzi+wMv8/b3novq76gvnqZp7/wdQp7p5jet59Tzz1FFCU0GnV273sDuxsJn/vYH7HammPH6DiVcZuoc4bnn3yWQ8Zh7E4JuX4ZOTOC/3QTa/Ze1EqHtJyxbVcJ5cSoJJeUSvVzyDTG3V6ncSFmpasYP3QQYhvDdIlSidCXiPP5EMhsCqO7mNnxAPWNH9P2dQ4dnOTChT185T/+Dz78wd9mdWmZbm+d299wO0/86PtoxASdnN28Wlu/5sd4XQHJMAyKxRK+30LTNdIk7U+JX9Gy6/QinEKFi5cXMSwLaeiYhhxk2bpuUC5X2L9/H/Pz8+zevZcozANJFIUocm92XdeZmprihhtuIAxDWn6jb7ynk6TZoMG7qZawOYkf9jPyOI6gv9F2u12O3P9W7rrtHjQM1tdXGBkZBXIDvzAMEYj8BREa67UNXNuhMrmD2LDRk5Sx0ZxIIWRGvVHDMk0sUcF1HWZ2TOK3tuZMy/WIURqGns8dqAyVpSgkupCYWi6KqbkW0J+H6ZuRtVqtwde2beO6Lq7rEscxpVJpEATjOEZJQbFSJu3L0luWhWHaOAUP0/aRKsQruER9On6SxhSKHlJa9OI0V1n3PFY3mkxNTRGGIX67R5xJFhcvsWfvrn5f0aBoF/EqDknco7a8yNh4BbezgVMcpZZ1sQybZnOLrpm4Inor+j2jzc/4Zl92oEm4OV/2MmySIbYqXq1s01aVe9okYmiaxmqzwdoPn+DCUz/m0L1v4YljC7zvPb9IkmzjX/zLj9Op+dz+pnfy40e+wA++V+HvvfUwO8ZneOGpGsePXiDuxNx/JOb03POgbI4/8T2clXlGbrmNc4+afOUrL3LLwYMompydj9mwF/HjOVytx7ZWifvKe/HbNc4Vlzl6qMzxb3yNN+6cJuo12bdnmk5gEgR17J6GG9RoNjO+c+EU2gvHWFlbIGmvsbogaLYaRFEPPw3pChNNfQKRBtieRmViAqc0S5LA57/wh7zzwYfYNbuH2+68lWajwZnTP0Y3CqQyn/2kd20tjev61AZByPlzC+zfv58k7dHr9fLygWYQhiFZlmBo+TDlxOR2FhYv43kuup6iUoUmdQwdkjhhvFqmsb5B1G1huRUyFYNM0KXZl0HREELjnnvexK233s53vvtXnDt3ho3aGpm6kjVuem6kaYpteWRpgm4AKsWwHDy3xAc+8GEKxSKGKYjjXm4saNqkSUasImzLxjVcmp0Gvt/Bdbzcb8bQ6HabhEkGwuvLsiiq1VGSJGHb5ASu67C2tjaYvdhqUORMFyVB9nkXA6Xv/j8A3ZKYhoNjmmjdEI10QLVNkxRlWKSmQxYlZJrCsoxBQpAkCWHfjMswLNJU0en0GBnJ+0VKSbI0I0kFzVaX0bEqmcjI9PxE3YvzXmNxdFuuKSgjlNAxghDLNsmEji0VSoImDbYXK9TrDTIhMS2bTt0njBPavQ4ze/eSZvnJDHRQReprl5nYNgXaTqIwY/tYhctLS0xNTXHx3NnXbW3+Jlytxp4kSU7Q2BTF7QcnSR6weNlJKMs2+zNbk/oppYEQ1ya4mVPYr6h9a1vzUAvkfVcpBZGWUdAF73nwXsJClUN33MNYxeOLX/oy/+BDDzJecYmjhOnZd/Mnf/wf6DQ7YEbUmitsOzDOE48e45nHn2ZhbY43HXkrn/3afwGtyl3bJrjgX+bs/BKPn1hm575dJMk2nFYTJY/z6Nln2D96B3Z9lTMVnfkzpznUezMrzRpH156j69d5+mjEmGWgOYIkhUbssNyIuXCix1rPYO9uwWxVsfPNCY7nkWYaUXOKUmGUt9w/y9wlH787xtLKDgrjN3H0ySeQwDcfeYRPfuJP0PVR3vWOXfzp6QskWYNKpcLFpWvv1V53D0nXdU6ePEmlUmHXrp10Oh3SJBrYgA+GTA2D7du3s7GxweTkJIZhDUgOlmUjtYzZ2VmOP/8CB266CU1ZSGySJBxQrDctBGzb5hd/4SHa7RZ/9d1vs7y8hO/7dLv5IGwcx6RpiuPZpClIaXPg0CyHbjpEqVShXKrS6+SZvGVZoOQgmAoEcdij0WuSYVIoFOj1pS42ry2ENtCsi+MYx3U5cOAAURT0y1blLTsfAS8tv2zaXcNmUzz/vm077N93iHa3TvvsAgYKIUCoDKHpdESKJN/sNlmUm9T/TWZdsVgkSWKyLEZhcfLFU9RrdXTdZXJbmWKhmM8jhTFCgGXmA6CVSgVNGkhpACFC6FiWjkISRT0SFZOlEqFLnGKBTi/CMGxqGzUgo9frcfnyMnHawkwkruugaSaarpPEglJlmjAx0WIPKRRhFFIpj0PWeV3W46fhanknYOBztKlXt6ldt+mP9PJcSJEPNG9lXE3O+EnYLNFtVYXvl0Dl+0XuPw9hAJ/56hPs3L2L06efxS5uELaKnHi8xfiojTs6SmY+zcSEZH19jU9/4xH2l4u878YqjR8q3r4/4IVpC9d+gV94yzRvf/AjzJ38EYf3xpx7OmD+2Pc5/3+PUeuGlMIOxe0emoxovHCJ26IxzFsPYlcPcvimO/DmOnz47x/AtStYtsCyTdBslLBoXIp5+ug6//7Ml/jwg7/GPW9X7J1ycIyYOO6RJBFBAqeePUGaCg7uniaWJcanBYYzjW2boBQyhd/72L/iXe94J7PTs7z/4Qf4xl9+i0atTsEyCMOfrvIO1xmQ0iTPmj3Po16v02zmwpQ33ngDUkq63c5LRR4z6PYi1lfXGBkrYVomEhPdkIBLsZhx512HOX1qnkpljEp5hKz/4imlQGkUSrltRSfwKVdKvP/9v0TUPxXl18kAiRA6xUIJIQVnz57F0A2yvn2uSGMcy84lVsKIQqEMpGQqIVxdI87AKZQQRv6il+0KKs0G3j66JgijHrptc/Phm2m3fLI0wdB12r6fb/Bbdj7iyn0NAtPm5ibA1AyyLEUgWVxcwrAEiaYQWQYIRKZI0ozIdrH6f6NpWYRRhGlZg9KSruein4WiTalcwDZNeutLyKCGEnVOH5tnctduuu0urabPjtlZDDMhjrqMjo6hS5N6bQPXLdPxfRq1DVxbomsGaZoRRRFhL2Kj1cYtVPH9gCTNaPtNkiSh02nheBKVCoQwSYIeUbBKuyOwi2USlVJbq2G7GoiUbrdJ1Nt4Hdbj2qBpGogreoJXK3oPSCo/8SOXG2JufVzbfV59QtqqECIn/+i6TpJlKJHRE4oX5s7zkTvfxfve+yZKXjOXDFKK1NBZPFumdm6WtSDkH/3OPyFWj3Lsub+gFvgcXzrHw7/xG0R2gXuTLqsLXVpLgl/+yD/jR5dPUt25SqtygbcUj3CPfoCj7dOEps8ts4ewL8Q82TjPkd88wrGTT/PuD72R8lQB2xjLPz9BiyBSzJ+/zH/7g8d46Mh/ouLN8+Z3v50oPEqcNkixiGKJZRUxDJ3C2HYKUwYFo0qARWQ3+epXvo/KNAzTyP2M05BvfuvrfPwTnyEzTA7c/AB//tXPcfTYd6/5OV63UoOUkjAMqVarg1PD0tIqcRyzf/8+0iSk1WoOsjrHcVhZXUY3oDJS6Qsx5sOycRKQZTrTM9s4f36BSqWEaVhEUTSYSu908iz2aqkbHYmm59/PxRoF5dIoC5cX6PVyozjTNPBbAcVicfBzppmXA7utOpoOaRahOwVsy0HqFknSfYkStq7rmKZJoFJmt2+jUiiyvrbSfzESgiCnrdu2je/71/UoXzsIMqWQQpCqDE3XkWY+66HiXEQzn2uJ2LV3HyNuEeOWCBXnm14YBKyuLLHSqA/6Qa2Wz+xOA7cvLpurrXuUSiUc18CybMrlMnoaUSm5bNTrZGnG+uIc1aLDxmqAylJm9+2hUvBI4hRpahiuQzcIqNXWyLodMquMQKPXDfLkQGXEqcLvdLEdD7/dpVIZ4ezZswgCstjE8hRSi2mvnML1HFIN9LRAmmiEiY+IbAzTpNPp0PPbr/fivDKEGJSAN2eNBr2T/lrm332lU9Bmkma+Nvf6KpEnrhFSmvykoCT6f+eA2CC2rnTQ5tyXUgqVpkizz4LUM/73n3+bM6dqfPADb2bPXo+i53H2wiLnjo8y4+7EMi7T8J/k3vt3497yMF985DQP/dpvk0iJUjGaqjI5a/DeX3kbXS7RfbbD7voGN88+xJg2TuJYWGqEw/4MWnsaJh3u6lR59LETvO9XbkNYgid/+CKC89x+x420azVePH2elY0W7ugIG+0aF5cW2HXDAb78vx5hz9vKKJqMjrjopsRfSzA0cByDMHRYa/ZodVz+z1/+d3rROro+gq5DGLVJgWeeepS77zpClAa8+x0PUFs+z7Otk9f0HK+vZCclmdCI+2Ue3/f7g5EpSRLx4osnKXolduyYJknjXNXAtbGLHu2gi9HR8bxcGy6KFYZhkmUKx/GYnp7mueef5va7juTBJwHdyDD7pxaVWbTDXMsuDzCSJEkpVzziJGHu3OlcPcAwsE0L0Ng2tYMgbBN2QpKuIhvVSHotPCnpZQZCq6IZEUkSYkpFEsVkMsW2bZI0yTdy0+DAxE7a7Ra1jTVUlvbvL0ECKs2ob9TQr8en9zWFGvQeLNfB8zyiNBeEJc2Q5Cda0yhy4MbDiDQ/qreDvEHrViD1W2idXM/ONM2B/9PmDJLjOAOX0jCIydIuhmaSIBC6lTMZLZ2uLyh6uWCnLlKWF5co7NvN+vo65XKZTEVkUYdSySK2M4I4lzhab+TX0DQDTQpUJlir5eZ658+ff8kJotNaQ0QQqHxM3G81KBYcojAlUxFBkJBmJohcGHar4iWq7JsDylf1lQTiFc8LAzO7rblvvwRJmmJeR2Xx5aMKWxFZluUk/DQXsUVkaE7KibNH6Xx2jcnJCu988O1oloFjjROnLqZKuHnvCE7WIM3KjI4YtOMIxxRkETh6gFAxqVUizSSFQpO3Gb9OlvWQsc6Xvae4W+1HG3VRmCSGjmWU0c7kZCAvVNx66x6CruLc2XlOP/88Ow4cZOH4IkfuO0jrwhoikiy9GHH5pOLsgS5vuKmKokPUU3T9gGpZg6BKrRlwei7imRfnuXR5DsuwibPcRNBxi3TCgM9/8T8zM2FRrSokHg8//A959uP/+pqe3/UpNSQJUa9NGoQk/c1NKYVt20R9W2qhBAsLCyAy9u7ZQ7PVpFwe4cK5OVzLwzRyrxxNSwY9KdPMh1enp6eZm5tjx45d+e+MewNZGl2z8v4PedZYKBRQSnFxcXGw4fq+j+d5OI5DlmX4vk+aRXkQi5qMigK+tIk0EBnESRfL9ZDS7F+nxejoKHEcY3gu05Pb0JRgfX0dyBAy3wI2mU6WaRIE4aAXtRUhhMR13bwXpuX9HkfXqNfrlIplahs1brvtNqZ376dYHkGpgI11hW2nCKDb6bK2uIbm5rMpkJ80gyAYaPttlpHCMCQIIoTI5ZxMLYUko1EPKRQtqqURRCaxXZMw6mFqLrVabWB3bloaZadKh5ykEMYJnU6HjFzuR2UQRAm6ZdBsNgdKBEtLS8RxjGVZ6IaJQ4eeUWb+wiK6UKRJhJIOujWKEhrr65cJgw1s7Wc/Y/OzwtXU7s3nq2laX7A9I5cX3LqCvj8NUkiy7PrVTdJX8TOvBURfiy9ftyuW8prIy962ZXFpeYlLKws8+dQxqtUp7tj/MI48Q7Eas3+tiq5plIoFmo0EjQpR0AOlEQEIDSFNcEzCWYdwXceKHeqlDtsP78D7QQlpWijNxlYaWDbjlVmaqzFp0abbC1i8NM/S8gL33383sRbw3vfdjMjKfPPkPF5Z51tfeoyDM/fw4+9+nVsPTpFkHXrdhOVmxLbpEo1OxNe++Ryf+fyXCQcuB31z0s2Eiby0+sk//AM++KFfJUpatDo/J+kgKSWGUGDk/QKpidynKI7xPA/LsnJV7SSfCzl15iwFr8jMzDak0KhvrKBrGo5bQMg0pxTrGpkuCSUsXV7m8G13opQgyxKkJnOvHi3Xq0lTsF0Lw9C5eHGRLMnyeSLfz19awLUt4igEaaAEhEGA5prYpkYnTfFtHUtJVBwhSHN5fpHru42MjpKpjHKlzNj0drrNFoRRTofOUpQQWLqByhQoQRRGg2x0q9JR82FmA8Oy0QRoQuLYDokbEUQBKMXF9Q0O3nYfUsboqYVnZaxcruFWt7G+fAbDUpBqmLadB/p2m4nJyQHza3P9u90u0khwrDE0XTBSKbG6uoQ36qCiFOmWiLKMquth9yICEQxKwO12m6IoImRCEMWkiYQMdKnTaq3myhulUaRhsb5RQyjFyuXLBEFAvdak22uQKRsjhXaSU/mzOMT0qliOg8wUdsmh7XeJow20TCGNrblmKAWZQggDkpBEahgyV9fffPmzzaSOl8oDRVGIYW7V0/oVKKWRpjGQ8krb0OBUSM60A0jTEKG2qs1LDiH6g/IDRmSCZVn5rKajIYSF4wp6aY3Hn/0cWU9HyIzn5kZ4x9veyMz0DtbWFXOn1qmMmNi2SVZIiNMEKRIEFvbd2/iLTx3jl/bczcmxVUrbXRxvBD8NOGF3WO91eXNWweq4HD91DuVIThx7mjuPzHLffUf4/d/9FL/3b/4pBS1COB064TKr9UV2T+yl12zS2ihz8vmIWr1Bbb3L0eeWSPFZOLfOkyfmyURMEkeoTNFu53Jqqq8Aj8xt1lEZn/6zz6AhrytZF9cjViiEWAMuvIp1+ruCnUqp8df7Jq7GcM1+KoZr9rcPwzX724drWrPrCkhDDDHEEEMM8fPC1h5WGGKIIYYY4u8MhgFpiCGGGGKILYFhQBpiiCGGGGJLYBiQhhhiiCGG2BIYBqQhhhhiiCG2BIYBaYghhhhiiC2BYUAaYoghhhhiS2AYkIYYYoghhtgSGAakIYYYYoghtgT+HyQT/7bZhV3yAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "examples = enumerate(trainloader)\n",
    "batch_idx, (example_data, example_label) = next(examples)\n",
    "# 批量展示图片\n",
    "for i in range(4):\n",
    "    plt.subplot(1, 4, i + 1)\n",
    "    plt.tight_layout()  #自动调整子图参数，使之填充整个图像区域\n",
    "    img = example_data[i]\n",
    "    img = img.numpy() # FloatTensor转为ndarray\n",
    "    img = np.transpose(img, (1,2,0)) # 把channel那一维放到最后\n",
    "    img = img * [0.5, 0.5, 0.5] + [0.5, 0.5, 0.5]\n",
    "    #img = img * [0.229, 0.224, 0.225] + [0.485, 0.456, 0.406]\n",
    "    plt.imshow(img)\n",
    "    plt.title(\"label:{}\".format(example_label[i]))\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c60bb0ee",
   "metadata": {},
   "source": [
    "## 2. 搭建GoogLeNet神经网络结构"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c35ab683",
   "metadata": {},
   "outputs": [],
   "source": [
    "class GoogLeNet(nn.Module):\n",
    "    def __init__(self, num_classes=2, aux_logits=True, init_weights=False):\n",
    "        super(GoogLeNet, self).__init__()\n",
    "        self.aux_logits = aux_logits\n",
    "        \n",
    "        self.conv1 = BasicConv2d(3, 64, kernel_size=7, stride=2, padding=3)\n",
    "        self.maxpool1 = nn.MaxPool2d(3, stride=2, ceil_mode=True)\n",
    "\n",
    "        self.conv2 = BasicConv2d(64, 64, kernel_size=1)\n",
    "        self.conv3 = BasicConv2d(64, 192, kernel_size=3, padding=1)\n",
    "        self.maxpool2 = nn.MaxPool2d(3, stride=2, ceil_mode=True)\n",
    "\n",
    "        self.inception3a = Inception(192, 64, 96, 128, 16, 32, 32)\n",
    "        self.inception3b = Inception(256, 128, 128, 192, 32, 96, 64)\n",
    "        self.maxpool3 = nn.MaxPool2d(3, stride=2, ceil_mode=True)\n",
    "\n",
    "        self.inception4a = Inception(480, 192, 96, 208, 16, 48, 64)\n",
    "        self.inception4b = Inception(512, 160, 112, 224, 24, 64, 64)\n",
    "        self.inception4c = Inception(512, 128, 128, 256, 24, 64, 64)\n",
    "        self.inception4d = Inception(512, 112, 144, 288, 32, 64, 64)\n",
    "        self.inception4e = Inception(528, 256, 160, 320, 32, 128, 128)\n",
    "        self.maxpool4 = nn.MaxPool2d(3, stride=2, ceil_mode=True)\n",
    "\n",
    "        self.inception5a = Inception(832, 256, 160, 320, 32, 128, 128)\n",
    "        self.inception5b = Inception(832, 384, 192, 384, 48, 128, 128)\n",
    "\n",
    "        if self.aux_logits:\n",
    "            self.aux1 = InceptionAux(512, num_classes)\n",
    "            self.aux2 = InceptionAux(528, num_classes)\n",
    "\n",
    "        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n",
    "        self.dropout = nn.Dropout(0.4)\n",
    "        self.fc = nn.Linear(1024, num_classes)\n",
    "        if init_weights:\n",
    "            self._initialize_weights()\n",
    "\n",
    "    def forward(self, x):\n",
    "        #------ 输入块 ------#\n",
    "        # N x 3 x 224 x 224\n",
    "        x = self.conv1(x)\n",
    "        # N x 64 x 112 x 112\n",
    "        x = self.maxpool1(x)\n",
    "        # N x 64 x 56 x 56\n",
    "        x = self.conv2(x)\n",
    "        # N x 64 x 56 x 56\n",
    "        x = self.conv3(x)\n",
    "        # N x 192 x 56 x 56\n",
    "        x = self.maxpool2(x)\n",
    "        \n",
    "        #------ Inception 4a/4b ------#\n",
    "        # N x 192 x 28 x 28\n",
    "        x = self.inception3a(x)\n",
    "        # N x 256 x 28 x 28\n",
    "        x = self.inception3b(x)\n",
    "        # N x 480 x 28 x 28\n",
    "        x = self.maxpool3(x)\n",
    "        # N x 480 x 14 x 14\n",
    "        x = self.inception4a(x)\n",
    "        #------ 辅助分类器 1 ------#\n",
    "        # N x 512 x 14 x 14\n",
    "        if self.training and self.aux_logits:    # eval model lose this layer\n",
    "            aux1 = self.aux1(x)\n",
    "\n",
    "        #------ Inception 4b/4c/4d ------# \n",
    "        x = self.inception4b(x)\n",
    "        # N x 512 x 14 x 14\n",
    "        x = self.inception4c(x)\n",
    "        # N x 512 x 14 x 14\n",
    "        x = self.inception4d(x)\n",
    "        #------ 辅助分类器 2 ------#\n",
    "        # N x 528 x 14 x 14\n",
    "        if self.training and self.aux_logits:    # eval model lose this layer\n",
    "            aux2 = self.aux2(x)\n",
    "\n",
    "        #------ Inception 4e/5a/5b ------# \n",
    "        x = self.inception4e(x)\n",
    "        # N x 832 x 14 x 14\n",
    "        x = self.maxpool4(x)\n",
    "        # N x 832 x 7 x 7\n",
    "        x = self.inception5a(x)\n",
    "        # N x 832 x 7 x 7\n",
    "        x = self.inception5b(x)\n",
    "        # N x 1024 x 7 x 7\n",
    "\n",
    "        #------ 输出块 ------# \n",
    "        x = self.avgpool(x)\n",
    "        # N x 1024 x 1 x 1\n",
    "        x = torch.flatten(x, 1)\n",
    "        # N x 1024\n",
    "        x = self.dropout(x)\n",
    "        x = self.fc(x)\n",
    "        # N x 1000 (num_classes)\n",
    "        if self.training and self.aux_logits:   # eval model lose this layer\n",
    "            return x, aux2, aux1\n",
    "        return x\n",
    "\n",
    "    def _initialize_weights(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\n",
    "                if m.bias is not None:\n",
    "                    nn.init.constant_(m.bias, 0)\n",
    "            elif isinstance(m, nn.Linear):\n",
    "                nn.init.normal_(m.weight, 0, 0.01)\n",
    "                nn.init.constant_(m.bias, 0)\n",
    "\n",
    "\n",
    "class Inception(nn.Module):\n",
    "    def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj):\n",
    "        super(Inception, self).__init__()\n",
    "\n",
    "        self.branch1 = BasicConv2d(in_channels, ch1x1, kernel_size=1)\n",
    "\n",
    "        self.branch2 = nn.Sequential(\n",
    "            BasicConv2d(in_channels, ch3x3red, kernel_size=1),\n",
    "            BasicConv2d(ch3x3red, ch3x3, kernel_size=3, padding=1)   # 保证输出大小等于输入大小\n",
    "        )\n",
    "\n",
    "        self.branch3 = nn.Sequential(\n",
    "            BasicConv2d(in_channels, ch5x5red, kernel_size=1),\n",
    "            BasicConv2d(ch5x5red, ch5x5, kernel_size=5, padding=2)   # 保证输出大小等于输入大小\n",
    "        )\n",
    "\n",
    "        self.branch4 = nn.Sequential(\n",
    "            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),\n",
    "            BasicConv2d(in_channels, pool_proj, kernel_size=1)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        branch1 = self.branch1(x)\n",
    "        branch2 = self.branch2(x)\n",
    "        branch3 = self.branch3(x)\n",
    "        branch4 = self.branch4(x)\n",
    "\n",
    "        outputs = [branch1, branch2, branch3, branch4]\n",
    "        return torch.cat(outputs, 1)\n",
    "\n",
    "\n",
    "class InceptionAux(nn.Module):\n",
    "    def __init__(self, in_channels, num_classes):\n",
    "        super(InceptionAux, self).__init__()\n",
    "        self.averagePool = nn.AvgPool2d(kernel_size=5, stride=3)\n",
    "        self.conv = BasicConv2d(in_channels, 128, kernel_size=1)  # output[batch, 128, 4, 4]\n",
    "\n",
    "        self.fc1 = nn.Linear(2048, 1024)\n",
    "        self.fc2 = nn.Linear(1024, num_classes)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # aux1: N x 512 x 14 x 14, aux2: N x 528 x 14 x 14\n",
    "        x = self.averagePool(x)\n",
    "        # aux1: N x 512 x 4 x 4, aux2: N x 528 x 4 x 4\n",
    "        x = self.conv(x)\n",
    "        # N x 128 x 4 x 4\n",
    "        x = torch.flatten(x, 1)\n",
    "        x = F.dropout(x, 0.5, training=self.training)\n",
    "        # N x 2048\n",
    "        x = F.relu(self.fc1(x), inplace=True)\n",
    "        x = F.dropout(x, 0.5, training=self.training)\n",
    "        # N x 1024\n",
    "        x = self.fc2(x)\n",
    "        # N x num_classes\n",
    "        return x\n",
    "\n",
    "\n",
    "class BasicConv2d(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels, **kwargs):\n",
    "        super(BasicConv2d, self).__init__()\n",
    "        self.conv = nn.Conv2d(in_channels, out_channels, **kwargs)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv(x)\n",
    "        x = self.relu(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a414c796",
   "metadata": {},
   "source": [
    "上面定义了完整的GoogLeNet V1网络。需要注意的是，类`Inception`定义了 Inception 模块的网络结构："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b50e310c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Inception(nn.Module):\n",
    "    def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj):\n",
    "        super(Inception, self).__init__()\n",
    "\n",
    "        self.branch1 = BasicConv2d(in_channels, ch1x1, kernel_size=1)\n",
    "\n",
    "        self.branch2 = nn.Sequential(\n",
    "            BasicConv2d(in_channels, ch3x3red, kernel_size=1),\n",
    "            BasicConv2d(ch3x3red, ch3x3, kernel_size=3, padding=1)   # 保证输出大小等于输入大小\n",
    "        )\n",
    "\n",
    "        self.branch3 = nn.Sequential(\n",
    "            BasicConv2d(in_channels, ch5x5red, kernel_size=1),\n",
    "            BasicConv2d(ch5x5red, ch5x5, kernel_size=5, padding=2)   # 保证输出大小等于输入大小\n",
    "        )\n",
    "\n",
    "        self.branch4 = nn.Sequential(\n",
    "            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),\n",
    "            BasicConv2d(in_channels, pool_proj, kernel_size=1)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        branch1 = self.branch1(x)\n",
    "        branch2 = self.branch2(x)\n",
    "        branch3 = self.branch3(x)\n",
    "        branch4 = self.branch4(x)\n",
    "\n",
    "        outputs = [branch1, branch2, branch3, branch4]\n",
    "        return torch.cat(outputs, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0769af3",
   "metadata": {},
   "source": [
    "![](./images/inception.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e323a545",
   "metadata": {},
   "source": [
    "类`InceptionAux`定义了辅助分类器模块的结构，辅助分类器只在训练的时候使用："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "aa8e5231",
   "metadata": {},
   "outputs": [],
   "source": [
    "class InceptionAux(nn.Module):\n",
    "    def __init__(self, in_channels, num_classes):\n",
    "        super(InceptionAux, self).__init__()\n",
    "        self.averagePool = nn.AvgPool2d(kernel_size=5, stride=3)\n",
    "        self.conv = BasicConv2d(in_channels, 128, kernel_size=1)  # output[batch, 128, 4, 4]\n",
    "\n",
    "        self.fc1 = nn.Linear(2048, 1024)\n",
    "        self.fc2 = nn.Linear(1024, num_classes)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # aux1: N x 512 x 14 x 14, aux2: N x 528 x 14 x 14\n",
    "        x = self.averagePool(x)\n",
    "        # aux1: N x 512 x 4 x 4, aux2: N x 528 x 4 x 4\n",
    "        x = self.conv(x)\n",
    "        # N x 128 x 4 x 4\n",
    "        x = torch.flatten(x, 1)\n",
    "        x = F.dropout(x, 0.5, training=self.training)\n",
    "        # N x 2048\n",
    "        x = F.relu(self.fc1(x), inplace=True)\n",
    "        x = F.dropout(x, 0.5, training=self.training)\n",
    "        # N x 1024\n",
    "        x = self.fc2(x)\n",
    "        # N x num_classes\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2f2c99a",
   "metadata": {},
   "source": [
    "![](./images/aux1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8e51b09",
   "metadata": {},
   "source": [
    "上图是辅助分类器 aux1 的结构图，aux2 结构与 aux1 完全相同。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e91b4dc3",
   "metadata": {},
   "source": [
    "GoogLeNet整体的网络结构可参照下图："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5c011fb",
   "metadata": {},
   "source": [
    "![](./images/structure.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c8221b9",
   "metadata": {},
   "source": [
    "定义GoogLeNet类的时候，参数num_classes指的是类别的数量，由于我们这里的数据集只有猫和狗两个类别，因此这里的全连接层的神经元个数做了微调。num_classes=2，输出层也是两个神经元，不是原来的1000个神经元。这里的改动大家注意一下，根据实际数据集的类别数量进行调整。整个网络的其它结构跟论文中的完全一样。\n",
    "\n",
    "函数initialize_weights()是对网络参数进行初始化操作，这里我们默认选择关闭初始化操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b9fa0b0",
   "metadata": {},
   "source": [
    "## 3. 将定义好的网络结构搭载到GPU/CPU，并定义优化器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6ca0ec5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#创建模型，部署gpu\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model_name = \"googlenet\"\n",
    "model = GoogLeNet(num_classes=2, aux_logits=True, init_weights=True)\n",
    "model.to(device)\n",
    "#定义优化器\n",
    "loss_function = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.0001)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f629e5c",
   "metadata": {},
   "source": [
    "这里我们将参数init_weights设为True，进行参数初始化操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c74f4fc",
   "metadata": {},
   "source": [
    "## 4. 定义训练过程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1480b6ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_runner(model, device, trainloader, loss_function, optimizer, epoch):\n",
    "    #训练模型, 启用 BatchNormalization 和 Dropout, 将BatchNormalization和Dropout置为True\n",
    "    model.train()\n",
    "    total = 0\n",
    "    correct =0.0\n",
    "    \n",
    "    #enumerate迭代已加载的数据集,同时获取数据和数据下标\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        inputs, labels = data\n",
    "        #把模型部署到device上\n",
    "        inputs, labels = inputs.to(device), labels.to(device)\n",
    "        #初始化梯度\n",
    "        optimizer.zero_grad()\n",
    "        #保存训练结果\n",
    "        #outputs = model(inputs)\n",
    "        logits, aux_logits2, aux_logits1 = model(inputs)\n",
    "        #计算损失和\n",
    "        #loss = F.cross_entropy(outputs, labels)\n",
    "        loss0 = loss_function(logits, labels)\n",
    "        loss1 = loss_function(aux_logits1, labels)\n",
    "        loss2 = loss_function(aux_logits2, labels)\n",
    "        loss = loss0 + loss1 * 0.3 + loss2 * 0.3\n",
    "        #获取最大概率的预测结果\n",
    "        #dim=1表示返回每一行的最大值对应的列下标\n",
    "        predict = logits.argmax(dim=1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predict == labels).sum().item()\n",
    "        #反向传播\n",
    "        loss.backward()\n",
    "        #更新参数\n",
    "        optimizer.step()\n",
    "        if i % 100 == 0:\n",
    "            #loss.item()表示当前loss的数值\n",
    "            print(\"Train Epoch{} \\t Loss: {:.6f}, accuracy: {:.6f}%\".format(epoch, loss.item(), 100*(correct/total)))\n",
    "            Loss.append(loss.item())\n",
    "            Accuracy.append(correct/total)\n",
    "    return loss.item(), correct/total"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3400e955",
   "metadata": {},
   "source": [
    "## 5. 定义测试过程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "fbb063ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_runner(model, device, testloader):\n",
    "    #模型验证, 必须要写, 否则只要有输入数据, 即使不训练, 它也会改变权值\n",
    "    #因为调用eval()将不启用 BatchNormalization 和 Dropout, BatchNormalization和Dropout置为False\n",
    "    model.eval()\n",
    "    #统计模型正确率, 设置初始值\n",
    "    correct = 0.0\n",
    "    test_loss = 0.0\n",
    "    total = 0\n",
    "    #torch.no_grad将不会计算梯度, 也不会进行反向传播\n",
    "    with torch.no_grad():\n",
    "        for data, label in testloader:\n",
    "            data, label = data.to(device), label.to(device)\n",
    "            output = model(data)\n",
    "            test_loss += F.cross_entropy(output, label).item()\n",
    "            predict = output.argmax(dim=1)\n",
    "            #计算正确数量\n",
    "            total += label.size(0)\n",
    "            correct += (predict == label).sum().item()\n",
    "        #计算损失值\n",
    "        print(\"test_avarage_loss: {:.6f}, accuracy: {:.6f}%\".format(test_loss/total, 100*(correct/total)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aad07306",
   "metadata": {},
   "source": [
    "## 6. 运行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "da7cb872",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start_time 2022-02-24 15:02:41\n",
      "Train Epoch1 \t Loss: 7.684023, accuracy: 51.562500%\n",
      "Train Epoch1 \t Loss: 1.043524, accuracy: 56.451114%\n",
      "Train Epoch1 \t Loss: 1.064129, accuracy: 58.869714%\n",
      "Train Epoch1 \t Loss: 1.019752, accuracy: 61.638289%\n",
      "test_avarage_loss: 0.019144, accuracy: 66.360000%\n",
      "end_time:  2022-02-24 15:05:25 \n",
      "\n",
      "start_time 2022-02-24 15:05:25\n",
      "Train Epoch2 \t Loss: 1.106810, accuracy: 62.500000%\n",
      "Train Epoch2 \t Loss: 0.887823, accuracy: 68.827351%\n",
      "Train Epoch2 \t Loss: 0.700395, accuracy: 71.571828%\n",
      "Train Epoch2 \t Loss: 0.919984, accuracy: 73.312915%\n",
      "test_avarage_loss: 0.013472, accuracy: 80.480000%\n",
      "end_time:  2022-02-24 15:08:06 \n",
      "\n",
      "start_time 2022-02-24 15:08:06\n",
      "Train Epoch3 \t Loss: 0.652730, accuracy: 84.375000%\n",
      "Train Epoch3 \t Loss: 0.631292, accuracy: 77.970297%\n",
      "Train Epoch3 \t Loss: 0.903582, accuracy: 79.213308%\n",
      "Train Epoch3 \t Loss: 0.604491, accuracy: 79.962625%\n",
      "test_avarage_loss: 0.011365, accuracy: 83.340000%\n",
      "end_time:  2022-02-24 15:10:44 \n",
      "\n",
      "start_time 2022-02-24 15:10:44\n",
      "Train Epoch4 \t Loss: 0.755165, accuracy: 79.687500%\n",
      "Train Epoch4 \t Loss: 0.621010, accuracy: 81.512995%\n",
      "Train Epoch4 \t Loss: 0.694677, accuracy: 83.115672%\n",
      "Train Epoch4 \t Loss: 0.373152, accuracy: 83.456188%\n",
      "test_avarage_loss: 0.010120, accuracy: 86.120000%\n",
      "end_time:  2022-02-24 15:13:25 \n",
      "\n",
      "start_time 2022-02-24 15:13:25\n",
      "Train Epoch5 \t Loss: 0.670051, accuracy: 81.250000%\n",
      "Train Epoch5 \t Loss: 0.450086, accuracy: 86.525371%\n",
      "Train Epoch5 \t Loss: 0.535969, accuracy: 86.745958%\n",
      "Train Epoch5 \t Loss: 0.722856, accuracy: 86.487749%\n",
      "test_avarage_loss: 0.008846, accuracy: 87.900000%\n",
      "end_time:  2022-02-24 15:16:06 \n",
      "\n",
      "start_time 2022-02-24 15:16:06\n",
      "Train Epoch6 \t Loss: 0.301050, accuracy: 95.312500%\n",
      "Train Epoch6 \t Loss: 0.595578, accuracy: 88.165223%\n",
      "Train Epoch6 \t Loss: 0.689157, accuracy: 88.020833%\n",
      "Train Epoch6 \t Loss: 0.549258, accuracy: 87.878945%\n",
      "test_avarage_loss: 0.008297, accuracy: 88.460000%\n",
      "end_time:  2022-02-24 15:18:47 \n",
      "\n",
      "start_time 2022-02-24 15:18:47\n",
      "Train Epoch7 \t Loss: 0.363243, accuracy: 92.187500%\n",
      "Train Epoch7 \t Loss: 0.344062, accuracy: 89.897896%\n",
      "Train Epoch7 \t Loss: 0.418308, accuracy: 89.972015%\n",
      "Train Epoch7 \t Loss: 0.419680, accuracy: 89.700997%\n",
      "test_avarage_loss: 0.008230, accuracy: 89.480000%\n",
      "end_time:  2022-02-24 15:21:24 \n",
      "\n",
      "start_time 2022-02-24 15:21:24\n",
      "Train Epoch8 \t Loss: 0.292661, accuracy: 93.750000%\n",
      "Train Epoch8 \t Loss: 0.271328, accuracy: 90.532178%\n",
      "Train Epoch8 \t Loss: 0.352347, accuracy: 91.029229%\n",
      "Train Epoch8 \t Loss: 0.455955, accuracy: 90.952035%\n",
      "test_avarage_loss: 0.007483, accuracy: 90.300000%\n",
      "end_time:  2022-02-24 15:24:02 \n",
      "\n",
      "start_time 2022-02-24 15:24:02\n",
      "Train Epoch9 \t Loss: 0.242111, accuracy: 93.750000%\n",
      "Train Epoch9 \t Loss: 0.215927, accuracy: 92.141089%\n",
      "Train Epoch9 \t Loss: 0.380158, accuracy: 92.210821%\n",
      "Train Epoch9 \t Loss: 0.266562, accuracy: 92.166736%\n",
      "test_avarage_loss: 0.007720, accuracy: 90.260000%\n",
      "end_time:  2022-02-24 15:26:39 \n",
      "\n",
      "start_time 2022-02-24 15:26:39\n",
      "Train Epoch10 \t Loss: 0.178616, accuracy: 95.312500%\n",
      "Train Epoch10 \t Loss: 0.264864, accuracy: 92.883663%\n",
      "Train Epoch10 \t Loss: 0.413150, accuracy: 93.151430%\n",
      "Train Epoch10 \t Loss: 0.608053, accuracy: 92.784468%\n",
      "test_avarage_loss: 0.006859, accuracy: 90.760000%\n",
      "end_time:  2022-02-24 15:29:17 \n",
      "\n",
      "start_time 2022-02-24 15:29:17\n",
      "Train Epoch11 \t Loss: 0.260797, accuracy: 93.750000%\n",
      "Train Epoch11 \t Loss: 0.303392, accuracy: 93.904703%\n",
      "Train Epoch11 \t Loss: 0.162833, accuracy: 93.866604%\n",
      "Train Epoch11 \t Loss: 0.431189, accuracy: 93.775955%\n",
      "test_avarage_loss: 0.006926, accuracy: 91.840000%\n",
      "end_time:  2022-02-24 15:31:58 \n",
      "\n",
      "start_time 2022-02-24 15:31:58\n",
      "Train Epoch12 \t Loss: 0.191669, accuracy: 96.875000%\n",
      "Train Epoch12 \t Loss: 0.206206, accuracy: 94.028465%\n",
      "Train Epoch12 \t Loss: 0.313167, accuracy: 94.263060%\n",
      "Train Epoch12 \t Loss: 0.245601, accuracy: 94.248339%\n",
      "test_avarage_loss: 0.006661, accuracy: 91.860000%\n",
      "end_time:  2022-02-24 15:34:35 \n",
      "\n",
      "start_time 2022-02-24 15:34:35\n",
      "Train Epoch13 \t Loss: 0.171917, accuracy: 96.875000%\n",
      "Train Epoch13 \t Loss: 0.158182, accuracy: 95.312500%\n",
      "Train Epoch13 \t Loss: 0.119852, accuracy: 95.320274%\n",
      "Train Epoch13 \t Loss: 0.239815, accuracy: 95.011420%\n",
      "test_avarage_loss: 0.006787, accuracy: 91.540000%\n",
      "end_time:  2022-02-24 15:37:16 \n",
      "\n",
      "start_time 2022-02-24 15:37:16\n",
      "Train Epoch14 \t Loss: 0.239372, accuracy: 93.750000%\n",
      "Train Epoch14 \t Loss: 0.183233, accuracy: 95.931312%\n",
      "Train Epoch14 \t Loss: 0.087114, accuracy: 95.670087%\n",
      "Train Epoch14 \t Loss: 0.253829, accuracy: 95.603198%\n",
      "test_avarage_loss: 0.006784, accuracy: 91.440000%\n",
      "end_time:  2022-02-24 15:39:53 \n",
      "\n",
      "start_time 2022-02-24 15:39:53\n",
      "Train Epoch15 \t Loss: 0.119883, accuracy: 98.437500%\n",
      "Train Epoch15 \t Loss: 0.370858, accuracy: 96.333540%\n",
      "Train Epoch15 \t Loss: 0.204806, accuracy: 96.105410%\n",
      "Train Epoch15 \t Loss: 0.199317, accuracy: 95.857558%\n",
      "test_avarage_loss: 0.005793, accuracy: 92.140000%\n",
      "end_time:  2022-02-24 15:42:28 \n",
      "\n",
      "start_time 2022-02-24 15:42:28\n",
      "Train Epoch16 \t Loss: 0.114498, accuracy: 100.000000%\n",
      "Train Epoch16 \t Loss: 0.189806, accuracy: 96.766708%\n",
      "Train Epoch16 \t Loss: 0.189556, accuracy: 96.354167%\n",
      "Train Epoch16 \t Loss: 0.184823, accuracy: 96.111919%\n",
      "test_avarage_loss: 0.010026, accuracy: 90.100000%\n",
      "end_time:  2022-02-24 15:45:03 \n",
      "\n",
      "start_time 2022-02-24 15:45:03\n",
      "Train Epoch17 \t Loss: 0.242314, accuracy: 93.750000%\n",
      "Train Epoch17 \t Loss: 0.440468, accuracy: 96.550124%\n",
      "Train Epoch17 \t Loss: 0.159499, accuracy: 96.532960%\n",
      "Train Epoch17 \t Loss: 0.217780, accuracy: 96.392234%\n",
      "test_avarage_loss: 0.006557, accuracy: 91.460000%\n",
      "end_time:  2022-02-24 15:47:39 \n",
      "\n",
      "start_time 2022-02-24 15:47:39\n",
      "Train Epoch18 \t Loss: 0.250579, accuracy: 95.312500%\n",
      "Train Epoch18 \t Loss: 0.148516, accuracy: 96.983292%\n",
      "Train Epoch18 \t Loss: 0.644809, accuracy: 96.906095%\n",
      "Train Epoch18 \t Loss: 0.080587, accuracy: 96.854236%\n",
      "test_avarage_loss: 0.007765, accuracy: 91.420000%\n",
      "end_time:  2022-02-24 15:50:20 \n",
      "\n",
      "start_time 2022-02-24 15:50:20\n",
      "Train Epoch19 \t Loss: 0.213704, accuracy: 92.187500%\n",
      "Train Epoch19 \t Loss: 0.286503, accuracy: 97.493812%\n",
      "Train Epoch19 \t Loss: 0.113858, accuracy: 97.232587%\n",
      "Train Epoch19 \t Loss: 0.294080, accuracy: 97.269518%\n",
      "test_avarage_loss: 0.006731, accuracy: 92.260000%\n",
      "end_time:  2022-02-24 15:52:58 \n",
      "\n",
      "start_time 2022-02-24 15:52:58\n",
      "Train Epoch20 \t Loss: 0.199732, accuracy: 96.875000%\n",
      "Train Epoch20 \t Loss: 0.240129, accuracy: 97.865099%\n",
      "Train Epoch20 \t Loss: 0.166743, accuracy: 97.660137%\n",
      "Train Epoch20 \t Loss: 0.117088, accuracy: 97.352575%\n",
      "test_avarage_loss: 0.007097, accuracy: 92.060000%\n",
      "end_time:  2022-02-24 15:55:37 \n",
      "\n",
      "Finished Training\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#调用\n",
    "epoch = 20\n",
    "Loss = []\n",
    "Accuracy = []\n",
    "for epoch in range(1, epoch+1):\n",
    "    print(\"start_time\",time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))\n",
    "    loss, acc = train_runner(model, device, trainloader, loss_function, optimizer, epoch)\n",
    "    Loss.append(loss)\n",
    "    Accuracy.append(acc)\n",
    "    test_runner(model, device, testloader)\n",
    "    print(\"end_time: \",time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())),'\\n')\n",
    "\n",
    "print('Finished Training')\n",
    "plt.subplot(2,1,1)\n",
    "plt.plot(Loss)\n",
    "plt.title('Loss')\n",
    "plt.show()\n",
    "plt.subplot(2,1,2)\n",
    "plt.plot(Accuracy)\n",
    "plt.title('Accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5594291",
   "metadata": {},
   "source": [
    "## 7. 保存模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8503096a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GoogLeNet(\n",
      "  (conv1): BasicConv2d(\n",
      "    (conv): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3))\n",
      "    (relu): ReLU(inplace=True)\n",
      "  )\n",
      "  (maxpool1): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=True)\n",
      "  (conv2): BasicConv2d(\n",
      "    (conv): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "    (relu): ReLU(inplace=True)\n",
      "  )\n",
      "  (conv3): BasicConv2d(\n",
      "    (conv): Conv2d(64, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (relu): ReLU(inplace=True)\n",
      "  )\n",
      "  (maxpool2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=True)\n",
      "  (inception3a): Inception(\n",
      "    (branch1): BasicConv2d(\n",
      "      (conv): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (relu): ReLU(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(192, 96, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(96, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(192, 16, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(192, 32, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inception3b): Inception(\n",
      "    (branch1): BasicConv2d(\n",
      "      (conv): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (relu): ReLU(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(128, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(256, 32, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(32, 96, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (maxpool3): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=True)\n",
      "  (inception4a): Inception(\n",
      "    (branch1): BasicConv2d(\n",
      "      (conv): Conv2d(480, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (relu): ReLU(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(480, 96, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(96, 208, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(480, 16, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(16, 48, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(480, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inception4b): Inception(\n",
      "    (branch1): BasicConv2d(\n",
      "      (conv): Conv2d(512, 160, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (relu): ReLU(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(512, 112, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(112, 224, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(24, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(512, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inception4c): Inception(\n",
      "    (branch1): BasicConv2d(\n",
      "      (conv): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (relu): ReLU(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(24, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(512, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inception4d): Inception(\n",
      "    (branch1): BasicConv2d(\n",
      "      (conv): Conv2d(512, 112, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (relu): ReLU(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(512, 144, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(144, 288, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(512, 32, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(512, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inception4e): Inception(\n",
      "    (branch1): BasicConv2d(\n",
      "      (conv): Conv2d(528, 256, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (relu): ReLU(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(528, 160, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(160, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(528, 32, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(32, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(528, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (maxpool4): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=True)\n",
      "  (inception5a): Inception(\n",
      "    (branch1): BasicConv2d(\n",
      "      (conv): Conv2d(832, 256, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (relu): ReLU(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(832, 160, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(160, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(832, 32, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(32, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (inception5b): Inception(\n",
      "    (branch1): BasicConv2d(\n",
      "      (conv): Conv2d(832, 384, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (relu): ReLU(inplace=True)\n",
      "    )\n",
      "    (branch2): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(832, 192, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch3): Sequential(\n",
      "      (0): BasicConv2d(\n",
      "        (conv): Conv2d(832, 48, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(48, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (branch4): Sequential(\n",
      "      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n",
      "      (1): BasicConv2d(\n",
      "        (conv): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (aux1): InceptionAux(\n",
      "    (averagePool): AvgPool2d(kernel_size=5, stride=3, padding=0)\n",
      "    (conv): BasicConv2d(\n",
      "      (conv): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (relu): ReLU(inplace=True)\n",
      "    )\n",
      "    (fc1): Linear(in_features=2048, out_features=1024, bias=True)\n",
      "    (fc2): Linear(in_features=1024, out_features=2, bias=True)\n",
      "  )\n",
      "  (aux2): InceptionAux(\n",
      "    (averagePool): AvgPool2d(kernel_size=5, stride=3, padding=0)\n",
      "    (conv): BasicConv2d(\n",
      "      (conv): Conv2d(528, 128, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (relu): ReLU(inplace=True)\n",
      "    )\n",
      "    (fc1): Linear(in_features=2048, out_features=1024, bias=True)\n",
      "    (fc2): Linear(in_features=1024, out_features=2, bias=True)\n",
      "  )\n",
      "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
      "  (dropout): Dropout(p=0.4, inplace=False)\n",
      "  (fc): Linear(in_features=1024, out_features=2, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "print(model)\n",
    "torch.save(model, './models/googlenet-catvsdog.pth') #保存模型"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa6e6904",
   "metadata": {},
   "source": [
    "## 8. 模型测试"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e172ecec",
   "metadata": {},
   "source": [
    "下面使用一张猫狗大战测试集的图片进行模型的测试。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1eb3eca7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "概率： tensor([[0.0825, 0.9175]], device='cuda:0', grad_fn=<SoftmaxBackward>)\n",
      "预测类别： dog\n"
     ]
    }
   ],
   "source": [
    "from PIL import Image\n",
    "import numpy as np\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "    model = torch.load('./models/googlenet-catvsdog.pth') #加载模型\n",
    "    model = model.to(device)\n",
    "    model.eval()    #把模型转为test模式\n",
    "    \n",
    "    #读取要预测的图片\n",
    "    # 读取要预测的图片\n",
    "    img = Image.open(\"./images/test_dog.jpg\") # 读取图像\n",
    "    #img.show()\n",
    "    plt.imshow(img) # 显示图片\n",
    "    plt.axis('off') # 不显示坐标轴\n",
    "    plt.show()\n",
    "    \n",
    "    # 导入图片，图片扩展后为[1，1，32，32]\n",
    "    trans = transforms.Compose(\n",
    "        [\n",
    "            transforms.Resize((227,227)),\n",
    "            transforms.ToTensor(),\n",
    "            transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
    "            #transforms.Normalize(mean = [0.485, 0.456, 0.406],std = [0.229, 0.224, 0.225])\n",
    "        ])\n",
    "    img = trans(img)\n",
    "    img = img.to(device)\n",
    "    img = img.unsqueeze(0)  #图片扩展多一维,因为输入到保存的模型中是4维的[batch_size,通道,长，宽]，而普通图片只有三维，[通道,长，宽]\n",
    "    \n",
    "    # 预测 \n",
    "    # 预测 \n",
    "    classes = ('cat', 'dog')\n",
    "    output = model(img)\n",
    "    prob = F.softmax(output,dim=1) #prob是2个分类的概率\n",
    "    print(\"概率：\",prob)\n",
    "    value, predicted = torch.max(output.data, 1)\n",
    "    predict = output.argmax(dim=1)\n",
    "    pred_class = classes[predicted.item()]\n",
    "    print(\"预测类别：\",pred_class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ddbc30ba",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:.conda-pytorch] *",
   "language": "python",
   "name": "conda-env-.conda-pytorch-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
